assimp/port/Assimp.NET/Assimp.NET/AssimpSwigPort_wrap.cxx

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

#define SWIGCSHARP


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



#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_Assimp(
                                                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_Assimp(
                                                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_Assimp(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

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


#include "..\..\..\include\aiDefines.h"
#include "..\..\..\include\aiConfig.h"
#include "..\..\..\include\aiTypes.h"
#include "..\..\..\include\aiVersion.h"
#include "..\..\..\include\aiPostProcess.h"
#include "..\..\..\include\aiVector2D.h"
#include "..\..\..\include\aiVector3D.h"
#include "..\..\..\include\aiColor4D.h"
#include "..\..\..\include\aiMatrix3x3.h"
#include "..\..\..\include\aiMatrix4x4.h"
#include "..\..\..\include\aiCamera.h"
#include "..\..\..\include\aiLight.h"
#include "..\..\..\include\aiAnim.h"
#include "..\..\..\include\aiMesh.h"
#include "..\..\..\include\aiFileIO.h"
#include "..\..\..\include\aiMaterial.h"
#include "..\..\..\include\aiQuaternion.h"
#include "..\..\..\include\aiScene.h"
#include "..\..\..\include\aiTexture.h"
#include "..\..\..\include\assimp.hpp"
#include "..\..\..\include\IOSystem.h"
#include "..\..\..\include\IOStream.h"
#include "..\..\..\include\Logger.h"
#include "..\..\..\include\LogStream.h"
#include "..\..\..\include\NullLogger.h"
#include "..\..\..\include\ProgressHandler.h"


#include <string>


#include <stdexcept>


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

SWIGINTERN std::vector< aiVectorKey * > *aiNodeAnim_GetmPositionKeys(aiNodeAnim *self){
    std::vector<aiVectorKey *> *result = new std::vector<aiVectorKey *>;
    result->reserve(self->mNumPositionKeys);
	 	
    aiVectorKey *currentValue = (aiVectorKey *)self->mPositionKeys;
    aiVectorKey *valueLimit = (aiVectorKey *)self->mPositionKeys + self->mNumPositionKeys;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiQuatKey * > *aiNodeAnim_GetmRotationKeys(aiNodeAnim *self){
    std::vector<aiQuatKey *> *result = new std::vector<aiQuatKey *>;
    result->reserve(self->mNumRotationKeys);
	 	
    aiQuatKey *currentValue = (aiQuatKey *)self->mRotationKeys;
    aiQuatKey *valueLimit = (aiQuatKey *)self->mRotationKeys + self->mNumRotationKeys;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiVectorKey * > *aiNodeAnim_GetmScalingKeys(aiNodeAnim *self){
    std::vector<aiVectorKey *> *result = new std::vector<aiVectorKey *>;
    result->reserve(self->mNumScalingKeys);
	 	
    aiVectorKey *currentValue = (aiVectorKey *)self->mScalingKeys;
    aiVectorKey *valueLimit = (aiVectorKey *)self->mScalingKeys + self->mNumScalingKeys;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiMeshKey * > *aiMeshAnim_GetmKeys(aiMeshAnim *self){
    std::vector<aiMeshKey *> *result = new std::vector<aiMeshKey *>;
    result->reserve(self->mNumKeys);
	 	
    aiMeshKey *currentValue = (aiMeshKey *)self->mKeys;
    aiMeshKey *valueLimit = (aiMeshKey *)self->mKeys + self->mNumKeys;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiNodeAnim * > *aiAnimation_GetmChannels(aiAnimation *self){
    std::vector<aiNodeAnim *> *result = new std::vector<aiNodeAnim *>;
    result->reserve(self->mNumChannels);

    aiNodeAnim **currentValue = self->mChannels;
    aiNodeAnim **valueLimit = self->mChannels + self->mNumChannels;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiMeshAnim * > *aiAnimation_GetmMeshChannels(aiAnimation *self){
    std::vector<aiMeshAnim *> *result = new std::vector<aiMeshAnim *>;
    result->reserve(self->mNumMeshChannels);

    aiMeshAnim **currentValue = self->mMeshChannels;
    aiMeshAnim **valueLimit = self->mMeshChannels + self->mNumMeshChannels;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< unsigned int > *aiFace_GetmIndices(aiFace *self){
    std::vector<unsigned int > *result = new std::vector<unsigned int >;
    result->reserve(self->mNumIndices);

    for (unsigned int i = 0; i < self->mNumIndices; ++i) {
      result->push_back(self->mIndices[i]);
    }

    return result;
  }
SWIGINTERN std::vector< aiVertexWeight * > *aiBone_GetmWeights(aiBone *self){
    std::vector<aiVertexWeight *> *result = new std::vector<aiVertexWeight *>;
    result->reserve(self->mNumWeights);
	 	
    aiVertexWeight *currentValue = (aiVertexWeight *)self->mWeights;
    aiVertexWeight *valueLimit = (aiVertexWeight *)self->mWeights + self->mNumWeights;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiAnimMesh * > *aiMesh_GetmAnimMeshes(aiMesh *self){
    std::vector<aiAnimMesh *> *result = new std::vector<aiAnimMesh *>;
    result->reserve(self->mNumAnimMeshes);

    aiAnimMesh **currentValue = self->mAnimMeshes;
    aiAnimMesh **valueLimit = self->mAnimMeshes + self->mNumAnimMeshes;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiVector3D * > *aiMesh_GetmBitangents(aiMesh *self){
    std::vector<aiVector3D *> *result = new std::vector<aiVector3D *>;
    result->reserve(self->mNumVertices);
	 	
    aiVector3D *currentValue = (aiVector3D *)self->mBitangents;
    aiVector3D *valueLimit = (aiVector3D *)self->mBitangents + self->mNumVertices;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiBone * > *aiMesh_GetmBones(aiMesh *self){
    std::vector<aiBone *> *result = new std::vector<aiBone *>;
    result->reserve(self->mNumBones);

    aiBone **currentValue = self->mBones;
    aiBone **valueLimit = self->mBones + self->mNumBones;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< std::vector< aiColor4D * > > *aiMesh_GetmColors(aiMesh *self){
    std::vector< std::vector<aiColor4D*> > *result = new std::vector< std::vector<aiColor4D*> >;
    result->reserve(AI_MAX_NUMBER_OF_COLOR_SETS);

    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
      std::vector<aiColor4D *> currentElements;

      if (self->mColors[i] != 0) {
        currentElements.reserve(self->mNumVertices);

        aiColor4D *currentValue = self->mColors[i];
        aiColor4D *valueLimit = self->mColors[i] + self->mNumVertices;
        while (currentValue < valueLimit) {
          currentElements.push_back(currentValue);
          ++currentValue;
        }
      }

      result->push_back(currentElements);
    }

    return result;
  }
SWIGINTERN std::vector< aiFace * > *aiMesh_GetmFaces(aiMesh *self){
    std::vector<aiFace *> *result = new std::vector<aiFace *>;
    result->reserve(self->mNumFaces);
	 	
    aiFace *currentValue = (aiFace *)self->mFaces;
    aiFace *valueLimit = (aiFace *)self->mFaces + self->mNumFaces;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiVector3D * > *aiMesh_GetmNormals(aiMesh *self){
    std::vector<aiVector3D *> *result = new std::vector<aiVector3D *>;
    result->reserve(self->mNumVertices);
	 	
    aiVector3D *currentValue = (aiVector3D *)self->mNormals;
    aiVector3D *valueLimit = (aiVector3D *)self->mNormals + self->mNumVertices;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< aiVector3D * > *aiMesh_GetmTangents(aiMesh *self){
    std::vector<aiVector3D *> *result = new std::vector<aiVector3D *>;
    result->reserve(self->mNumVertices);
	 	
    aiVector3D *currentValue = (aiVector3D *)self->mTangents;
    aiVector3D *valueLimit = (aiVector3D *)self->mTangents + self->mNumVertices;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN std::vector< std::vector< aiVector3D * > > *aiMesh_GetmTextureCoords(aiMesh *self){
    std::vector< std::vector<aiVector3D*> > *result = new std::vector< std::vector<aiVector3D*> >;
    result->reserve(AI_MAX_NUMBER_OF_TEXTURECOORDS);

    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
      std::vector<aiVector3D *> currentElements;

      if (self->mTextureCoords[i] != 0) {
        currentElements.reserve(self->mNumVertices);

        aiVector3D *currentValue = self->mTextureCoords[i];
        aiVector3D *valueLimit = self->mTextureCoords[i] + self->mNumVertices;
        while (currentValue < valueLimit) {
          currentElements.push_back(currentValue);
          ++currentValue;
        }
      }

      result->push_back(currentElements);
    }

    return result;
  }
SWIGINTERN std::vector< unsigned int > *aiMesh_GetmNumUVComponents(aiMesh *self){
    std::vector<unsigned int > *result = new std::vector<unsigned int >;
    result->reserve(AI_MAX_NUMBER_OF_TEXTURECOORDS);

    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
      result->push_back(self->mNumUVComponents[i]);
    }

    return result;
  }
SWIGINTERN std::vector< aiVector3D * > *aiMesh_GetmVertices(aiMesh *self){
    std::vector<aiVector3D *> *result = new std::vector<aiVector3D *>;
    result->reserve(self->mNumVertices);
	 	
    aiVector3D *currentValue = (aiVector3D *)self->mVertices;
    aiVector3D *valueLimit = (aiVector3D *)self->mVertices + self->mNumVertices;
    while (currentValue < valueLimit) {
      result->push_back(currentValue);
      ++currentValue;
    }
 	
    return result;
  }
SWIGINTERN bool aiMaterial_GetDiffuse(aiMaterial *self,aiColor4D *INOUT){
         return aiGetMaterialColor(self, AI_MATKEY_COLOR_DIFFUSE, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetSpecular(aiMaterial *self,aiColor4D *INOUT){
         return aiGetMaterialColor(self, AI_MATKEY_COLOR_SPECULAR, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetAmbient(aiMaterial *self,aiColor4D *INOUT){
         return aiGetMaterialColor(self, AI_MATKEY_COLOR_AMBIENT, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetEmissive(aiMaterial *self,aiColor4D *INOUT){
         return aiGetMaterialColor(self, AI_MATKEY_COLOR_EMISSIVE, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetOpacity(aiMaterial *self,float *INOUT){
         return aiGetMaterialFloat(self, AI_MATKEY_OPACITY, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetShininessStrength(aiMaterial *self,float *INOUT){
         return aiGetMaterialFloat(self, AI_MATKEY_SHININESS_STRENGTH, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetShadingModel(aiMaterial *self,int *INOUT){
         return aiGetMaterialInteger(self, AI_MATKEY_SHADING_MODEL, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTexFlagsDiffuse0(aiMaterial *self,int *INOUT){
         return aiGetMaterialInteger(self, AI_MATKEY_TEXFLAGS_DIFFUSE(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetMappingModeUDiffuse0(aiMaterial *self,int *INOUT){
         return aiGetMaterialInteger(self, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetMappingModeVDiffuse0(aiMaterial *self,int *INOUT){
         return aiGetMaterialInteger(self, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureDiffuse0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_DIFFUSE(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureSpecular0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_SPECULAR(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureOpacity0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_OPACITY(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureAmbient0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_AMBIENT(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureEmissive0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_EMISSIVE(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureShininess0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_SHININESS(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureLightmap0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_LIGHTMAP(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureNormals0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_NORMALS(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTextureHeight0(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_TEXTURE_HEIGHT(0), INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetGlobalBackgroundImage(aiMaterial *self,aiString *INOUT){
         return aiGetMaterialString(self, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE, INOUT) == AI_SUCCESS;
  }
SWIGINTERN bool aiMaterial_GetTwoSided(aiMaterial *self,int *INOUT){
         return aiGetMaterialInteger(self, AI_MATKEY_TWOSIDED, INOUT) == AI_SUCCESS;
  }
SWIGINTERN std::vector< aiNode * > *aiNode_GetmChildren(aiNode *self){
    std::vector<aiNode *> *result = new std::vector<aiNode *>;
    result->reserve(self->mNumChildren);

    aiNode **currentValue = self->mChildren;
    aiNode **valueLimit = self->mChildren + self->mNumChildren;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< unsigned int > *aiNode_GetmMeshes(aiNode *self){
    std::vector<unsigned int > *result = new std::vector<unsigned int >;
    result->reserve(self->mNumMeshes);

    for (unsigned int i = 0; i < self->mNumMeshes; ++i) {
      result->push_back(self->mMeshes[i]);
    }

    return result;
  }
SWIGINTERN std::vector< aiAnimation * > *aiScene_GetmAnimations(aiScene *self){
    std::vector<aiAnimation *> *result = new std::vector<aiAnimation *>;
    result->reserve(self->mNumAnimations);

    aiAnimation **currentValue = self->mAnimations;
    aiAnimation **valueLimit = self->mAnimations + self->mNumAnimations;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiCamera * > *aiScene_GetmCameras(aiScene *self){
    std::vector<aiCamera *> *result = new std::vector<aiCamera *>;
    result->reserve(self->mNumCameras);

    aiCamera **currentValue = self->mCameras;
    aiCamera **valueLimit = self->mCameras + self->mNumCameras;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiLight * > *aiScene_GetmLights(aiScene *self){
    std::vector<aiLight *> *result = new std::vector<aiLight *>;
    result->reserve(self->mNumLights);

    aiLight **currentValue = self->mLights;
    aiLight **valueLimit = self->mLights + self->mNumLights;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiMaterial * > *aiScene_GetmMaterials(aiScene *self){
    std::vector<aiMaterial *> *result = new std::vector<aiMaterial *>;
    result->reserve(self->mNumMaterials);

    aiMaterial **currentValue = self->mMaterials;
    aiMaterial **valueLimit = self->mMaterials + self->mNumMaterials;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiMesh * > *aiScene_GetmMeshes(aiScene *self){
    std::vector<aiMesh *> *result = new std::vector<aiMesh *>;
    result->reserve(self->mNumMeshes);

    aiMesh **currentValue = self->mMeshes;
    aiMesh **valueLimit = self->mMeshes + self->mNumMeshes;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::vector< aiTexture * > *aiScene_GetmTextures(aiScene *self){
    std::vector<aiTexture *> *result = new std::vector<aiTexture *>;
    result->reserve(self->mNumTextures);

    aiTexture **currentValue = self->mTextures;
    aiTexture **valueLimit = self->mTextures + self->mNumTextures;
    while (currentValue < valueLimit) {
      result->push_back(*currentValue);
      ++currentValue;
    }

    return result;
  }
SWIGINTERN std::string Assimp_Importer_GetExtensionList__SWIG_2(Assimp::Importer *self){
    std::string tmp;
    self->GetExtensionList(tmp);
    return tmp;
  }
SWIGINTERN std::vector< float > *new_std_vector_Sl_float_Sg___SWIG_2(int capacity){
        std::vector< float >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< float >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN float std_vector_Sl_float_Sg__getitemcopy(std::vector< float > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< float >::const_reference std_vector_Sl_float_Sg__getitem(std::vector< float > *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_float_Sg__setitem(std::vector< float > *self,int index,float const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_float_Sg__AddRange(std::vector< float > *self,std::vector< float > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< float > *std_vector_Sl_float_Sg__GetRange(std::vector< float > *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< float >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_float_Sg__Insert(std::vector< float > *self,int index,float 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_float_Sg__InsertRange(std::vector< float > *self,int index,std::vector< float > 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_float_Sg__RemoveAt(std::vector< float > *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_float_Sg__RemoveRange(std::vector< float > *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< float > *std_vector_Sl_float_Sg__Repeat(float const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< float >(count, value);
      }
SWIGINTERN void std_vector_Sl_float_Sg__Reverse__SWIG_0(std::vector< float > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_float_Sg__Reverse__SWIG_1(std::vector< float > *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_float_Sg__SetRange(std::vector< float > *self,int index,std::vector< float > 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_float_Sg__Contains(std::vector< float > *self,float const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_float_Sg__IndexOf(std::vector< float > *self,float const &value){
        int index = -1;
        std::vector< float >::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_float_Sg__LastIndexOf(std::vector< float > *self,float const &value){
        int index = -1;
        std::vector< float >::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_float_Sg__Remove(std::vector< float > *self,float const &value){
        std::vector< float >::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 >::const_reference 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< aiAnimation * > *new_std_vector_Sl_aiAnimation_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiAnimation * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiAnimation * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiAnimation *std_vector_Sl_aiAnimation_Sm__Sg__getitemcopy(std::vector< aiAnimation * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiAnimation * >::const_reference std_vector_Sl_aiAnimation_Sm__Sg__getitem(std::vector< aiAnimation * > *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_aiAnimation_Sm__Sg__setitem(std::vector< aiAnimation * > *self,int index,aiAnimation *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiAnimation_Sm__Sg__AddRange(std::vector< aiAnimation * > *self,std::vector< aiAnimation * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiAnimation * > *std_vector_Sl_aiAnimation_Sm__Sg__GetRange(std::vector< aiAnimation * > *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< aiAnimation * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiAnimation_Sm__Sg__Insert(std::vector< aiAnimation * > *self,int index,aiAnimation *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_aiAnimation_Sm__Sg__InsertRange(std::vector< aiAnimation * > *self,int index,std::vector< aiAnimation * > 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_aiAnimation_Sm__Sg__RemoveAt(std::vector< aiAnimation * > *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_aiAnimation_Sm__Sg__RemoveRange(std::vector< aiAnimation * > *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< aiAnimation * > *std_vector_Sl_aiAnimation_Sm__Sg__Repeat(aiAnimation *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiAnimation * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiAnimation_Sm__Sg__Reverse__SWIG_0(std::vector< aiAnimation * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiAnimation_Sm__Sg__Reverse__SWIG_1(std::vector< aiAnimation * > *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_aiAnimation_Sm__Sg__SetRange(std::vector< aiAnimation * > *self,int index,std::vector< aiAnimation * > 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_aiAnimation_Sm__Sg__Contains(std::vector< aiAnimation * > *self,aiAnimation *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiAnimation_Sm__Sg__IndexOf(std::vector< aiAnimation * > *self,aiAnimation *const &value){
        int index = -1;
        std::vector< aiAnimation * >::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_aiAnimation_Sm__Sg__LastIndexOf(std::vector< aiAnimation * > *self,aiAnimation *const &value){
        int index = -1;
        std::vector< aiAnimation * >::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_aiAnimation_Sm__Sg__Remove(std::vector< aiAnimation * > *self,aiAnimation *const &value){
        std::vector< aiAnimation * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiAnimMesh * > *new_std_vector_Sl_aiAnimMesh_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiAnimMesh * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiAnimMesh * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiAnimMesh *std_vector_Sl_aiAnimMesh_Sm__Sg__getitemcopy(std::vector< aiAnimMesh * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiAnimMesh * >::const_reference std_vector_Sl_aiAnimMesh_Sm__Sg__getitem(std::vector< aiAnimMesh * > *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_aiAnimMesh_Sm__Sg__setitem(std::vector< aiAnimMesh * > *self,int index,aiAnimMesh *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiAnimMesh_Sm__Sg__AddRange(std::vector< aiAnimMesh * > *self,std::vector< aiAnimMesh * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiAnimMesh * > *std_vector_Sl_aiAnimMesh_Sm__Sg__GetRange(std::vector< aiAnimMesh * > *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< aiAnimMesh * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiAnimMesh_Sm__Sg__Insert(std::vector< aiAnimMesh * > *self,int index,aiAnimMesh *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_aiAnimMesh_Sm__Sg__InsertRange(std::vector< aiAnimMesh * > *self,int index,std::vector< aiAnimMesh * > 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_aiAnimMesh_Sm__Sg__RemoveAt(std::vector< aiAnimMesh * > *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_aiAnimMesh_Sm__Sg__RemoveRange(std::vector< aiAnimMesh * > *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< aiAnimMesh * > *std_vector_Sl_aiAnimMesh_Sm__Sg__Repeat(aiAnimMesh *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiAnimMesh * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiAnimMesh_Sm__Sg__Reverse__SWIG_0(std::vector< aiAnimMesh * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiAnimMesh_Sm__Sg__Reverse__SWIG_1(std::vector< aiAnimMesh * > *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_aiAnimMesh_Sm__Sg__SetRange(std::vector< aiAnimMesh * > *self,int index,std::vector< aiAnimMesh * > 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_aiAnimMesh_Sm__Sg__Contains(std::vector< aiAnimMesh * > *self,aiAnimMesh *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiAnimMesh_Sm__Sg__IndexOf(std::vector< aiAnimMesh * > *self,aiAnimMesh *const &value){
        int index = -1;
        std::vector< aiAnimMesh * >::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_aiAnimMesh_Sm__Sg__LastIndexOf(std::vector< aiAnimMesh * > *self,aiAnimMesh *const &value){
        int index = -1;
        std::vector< aiAnimMesh * >::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_aiAnimMesh_Sm__Sg__Remove(std::vector< aiAnimMesh * > *self,aiAnimMesh *const &value){
        std::vector< aiAnimMesh * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiBone * > *new_std_vector_Sl_aiBone_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiBone * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiBone * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiBone *std_vector_Sl_aiBone_Sm__Sg__getitemcopy(std::vector< aiBone * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiBone * >::const_reference std_vector_Sl_aiBone_Sm__Sg__getitem(std::vector< aiBone * > *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_aiBone_Sm__Sg__setitem(std::vector< aiBone * > *self,int index,aiBone *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiBone_Sm__Sg__AddRange(std::vector< aiBone * > *self,std::vector< aiBone * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiBone * > *std_vector_Sl_aiBone_Sm__Sg__GetRange(std::vector< aiBone * > *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< aiBone * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiBone_Sm__Sg__Insert(std::vector< aiBone * > *self,int index,aiBone *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_aiBone_Sm__Sg__InsertRange(std::vector< aiBone * > *self,int index,std::vector< aiBone * > 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_aiBone_Sm__Sg__RemoveAt(std::vector< aiBone * > *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_aiBone_Sm__Sg__RemoveRange(std::vector< aiBone * > *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< aiBone * > *std_vector_Sl_aiBone_Sm__Sg__Repeat(aiBone *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiBone * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiBone_Sm__Sg__Reverse__SWIG_0(std::vector< aiBone * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiBone_Sm__Sg__Reverse__SWIG_1(std::vector< aiBone * > *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_aiBone_Sm__Sg__SetRange(std::vector< aiBone * > *self,int index,std::vector< aiBone * > 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_aiBone_Sm__Sg__Contains(std::vector< aiBone * > *self,aiBone *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiBone_Sm__Sg__IndexOf(std::vector< aiBone * > *self,aiBone *const &value){
        int index = -1;
        std::vector< aiBone * >::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_aiBone_Sm__Sg__LastIndexOf(std::vector< aiBone * > *self,aiBone *const &value){
        int index = -1;
        std::vector< aiBone * >::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_aiBone_Sm__Sg__Remove(std::vector< aiBone * > *self,aiBone *const &value){
        std::vector< aiBone * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiCamera * > *new_std_vector_Sl_aiCamera_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiCamera * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiCamera * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiCamera *std_vector_Sl_aiCamera_Sm__Sg__getitemcopy(std::vector< aiCamera * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiCamera * >::const_reference std_vector_Sl_aiCamera_Sm__Sg__getitem(std::vector< aiCamera * > *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_aiCamera_Sm__Sg__setitem(std::vector< aiCamera * > *self,int index,aiCamera *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiCamera_Sm__Sg__AddRange(std::vector< aiCamera * > *self,std::vector< aiCamera * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiCamera * > *std_vector_Sl_aiCamera_Sm__Sg__GetRange(std::vector< aiCamera * > *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< aiCamera * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiCamera_Sm__Sg__Insert(std::vector< aiCamera * > *self,int index,aiCamera *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_aiCamera_Sm__Sg__InsertRange(std::vector< aiCamera * > *self,int index,std::vector< aiCamera * > 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_aiCamera_Sm__Sg__RemoveAt(std::vector< aiCamera * > *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_aiCamera_Sm__Sg__RemoveRange(std::vector< aiCamera * > *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< aiCamera * > *std_vector_Sl_aiCamera_Sm__Sg__Repeat(aiCamera *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiCamera * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiCamera_Sm__Sg__Reverse__SWIG_0(std::vector< aiCamera * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiCamera_Sm__Sg__Reverse__SWIG_1(std::vector< aiCamera * > *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_aiCamera_Sm__Sg__SetRange(std::vector< aiCamera * > *self,int index,std::vector< aiCamera * > 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_aiCamera_Sm__Sg__Contains(std::vector< aiCamera * > *self,aiCamera *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiCamera_Sm__Sg__IndexOf(std::vector< aiCamera * > *self,aiCamera *const &value){
        int index = -1;
        std::vector< aiCamera * >::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_aiCamera_Sm__Sg__LastIndexOf(std::vector< aiCamera * > *self,aiCamera *const &value){
        int index = -1;
        std::vector< aiCamera * >::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_aiCamera_Sm__Sg__Remove(std::vector< aiCamera * > *self,aiCamera *const &value){
        std::vector< aiCamera * >::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< aiColor4D * > > *new_std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< aiColor4D * > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< aiColor4D * > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< aiColor4D * > std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitemcopy(std::vector< std::vector< aiColor4D * > > *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< aiColor4D * > >::const_reference std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitem(std::vector< std::vector< aiColor4D * > > *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_aiColor4D_Sm__Sg__Sg__setitem(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< aiColor4D * > 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_aiColor4D_Sm__Sg__Sg__AddRange(std::vector< std::vector< aiColor4D * > > *self,std::vector< std::vector< aiColor4D * > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< aiColor4D * > > *std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__GetRange(std::vector< std::vector< aiColor4D * > > *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< aiColor4D * > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Insert(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< aiColor4D * > 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_aiColor4D_Sm__Sg__Sg__InsertRange(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< std::vector< aiColor4D * > > 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_aiColor4D_Sm__Sg__Sg__RemoveAt(std::vector< std::vector< aiColor4D * > > *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_aiColor4D_Sm__Sg__Sg__RemoveRange(std::vector< std::vector< aiColor4D * > > *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< aiColor4D * > > *std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Repeat(std::vector< aiColor4D * > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< aiColor4D * > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< aiColor4D * > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< aiColor4D * > > *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_aiColor4D_Sm__Sg__Sg__SetRange(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< std::vector< aiColor4D * > > 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< aiColor4D * > *new_std_vector_Sl_aiColor4D_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiColor4D * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiColor4D * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiColor4D *std_vector_Sl_aiColor4D_Sm__Sg__getitemcopy(std::vector< aiColor4D * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiColor4D * >::const_reference std_vector_Sl_aiColor4D_Sm__Sg__getitem(std::vector< aiColor4D * > *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_aiColor4D_Sm__Sg__setitem(std::vector< aiColor4D * > *self,int index,aiColor4D *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__AddRange(std::vector< aiColor4D * > *self,std::vector< aiColor4D * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiColor4D * > *std_vector_Sl_aiColor4D_Sm__Sg__GetRange(std::vector< aiColor4D * > *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< aiColor4D * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Insert(std::vector< aiColor4D * > *self,int index,aiColor4D *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_aiColor4D_Sm__Sg__InsertRange(std::vector< aiColor4D * > *self,int index,std::vector< aiColor4D * > 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_aiColor4D_Sm__Sg__RemoveAt(std::vector< aiColor4D * > *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_aiColor4D_Sm__Sg__RemoveRange(std::vector< aiColor4D * > *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< aiColor4D * > *std_vector_Sl_aiColor4D_Sm__Sg__Repeat(aiColor4D *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiColor4D * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Reverse__SWIG_0(std::vector< aiColor4D * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Reverse__SWIG_1(std::vector< aiColor4D * > *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_aiColor4D_Sm__Sg__SetRange(std::vector< aiColor4D * > *self,int index,std::vector< aiColor4D * > 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_aiColor4D_Sm__Sg__Contains(std::vector< aiColor4D * > *self,aiColor4D *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiColor4D_Sm__Sg__IndexOf(std::vector< aiColor4D * > *self,aiColor4D *const &value){
        int index = -1;
        std::vector< aiColor4D * >::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_aiColor4D_Sm__Sg__LastIndexOf(std::vector< aiColor4D * > *self,aiColor4D *const &value){
        int index = -1;
        std::vector< aiColor4D * >::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_aiColor4D_Sm__Sg__Remove(std::vector< aiColor4D * > *self,aiColor4D *const &value){
        std::vector< aiColor4D * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiFace * > *new_std_vector_Sl_aiFace_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiFace * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiFace * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiFace *std_vector_Sl_aiFace_Sm__Sg__getitemcopy(std::vector< aiFace * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiFace * >::const_reference std_vector_Sl_aiFace_Sm__Sg__getitem(std::vector< aiFace * > *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_aiFace_Sm__Sg__setitem(std::vector< aiFace * > *self,int index,aiFace *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiFace_Sm__Sg__AddRange(std::vector< aiFace * > *self,std::vector< aiFace * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiFace * > *std_vector_Sl_aiFace_Sm__Sg__GetRange(std::vector< aiFace * > *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< aiFace * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiFace_Sm__Sg__Insert(std::vector< aiFace * > *self,int index,aiFace *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_aiFace_Sm__Sg__InsertRange(std::vector< aiFace * > *self,int index,std::vector< aiFace * > 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_aiFace_Sm__Sg__RemoveAt(std::vector< aiFace * > *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_aiFace_Sm__Sg__RemoveRange(std::vector< aiFace * > *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< aiFace * > *std_vector_Sl_aiFace_Sm__Sg__Repeat(aiFace *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiFace * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiFace_Sm__Sg__Reverse__SWIG_0(std::vector< aiFace * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiFace_Sm__Sg__Reverse__SWIG_1(std::vector< aiFace * > *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_aiFace_Sm__Sg__SetRange(std::vector< aiFace * > *self,int index,std::vector< aiFace * > 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_aiFace_Sm__Sg__Contains(std::vector< aiFace * > *self,aiFace *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiFace_Sm__Sg__IndexOf(std::vector< aiFace * > *self,aiFace *const &value){
        int index = -1;
        std::vector< aiFace * >::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_aiFace_Sm__Sg__LastIndexOf(std::vector< aiFace * > *self,aiFace *const &value){
        int index = -1;
        std::vector< aiFace * >::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_aiFace_Sm__Sg__Remove(std::vector< aiFace * > *self,aiFace *const &value){
        std::vector< aiFace * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiLight * > *new_std_vector_Sl_aiLight_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiLight * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiLight * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiLight *std_vector_Sl_aiLight_Sm__Sg__getitemcopy(std::vector< aiLight * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiLight * >::const_reference std_vector_Sl_aiLight_Sm__Sg__getitem(std::vector< aiLight * > *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_aiLight_Sm__Sg__setitem(std::vector< aiLight * > *self,int index,aiLight *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiLight_Sm__Sg__AddRange(std::vector< aiLight * > *self,std::vector< aiLight * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiLight * > *std_vector_Sl_aiLight_Sm__Sg__GetRange(std::vector< aiLight * > *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< aiLight * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiLight_Sm__Sg__Insert(std::vector< aiLight * > *self,int index,aiLight *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_aiLight_Sm__Sg__InsertRange(std::vector< aiLight * > *self,int index,std::vector< aiLight * > 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_aiLight_Sm__Sg__RemoveAt(std::vector< aiLight * > *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_aiLight_Sm__Sg__RemoveRange(std::vector< aiLight * > *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< aiLight * > *std_vector_Sl_aiLight_Sm__Sg__Repeat(aiLight *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiLight * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiLight_Sm__Sg__Reverse__SWIG_0(std::vector< aiLight * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiLight_Sm__Sg__Reverse__SWIG_1(std::vector< aiLight * > *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_aiLight_Sm__Sg__SetRange(std::vector< aiLight * > *self,int index,std::vector< aiLight * > 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_aiLight_Sm__Sg__Contains(std::vector< aiLight * > *self,aiLight *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiLight_Sm__Sg__IndexOf(std::vector< aiLight * > *self,aiLight *const &value){
        int index = -1;
        std::vector< aiLight * >::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_aiLight_Sm__Sg__LastIndexOf(std::vector< aiLight * > *self,aiLight *const &value){
        int index = -1;
        std::vector< aiLight * >::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_aiLight_Sm__Sg__Remove(std::vector< aiLight * > *self,aiLight *const &value){
        std::vector< aiLight * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiMaterial * > *new_std_vector_Sl_aiMaterial_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiMaterial * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiMaterial * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiMaterial *std_vector_Sl_aiMaterial_Sm__Sg__getitemcopy(std::vector< aiMaterial * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiMaterial * >::const_reference std_vector_Sl_aiMaterial_Sm__Sg__getitem(std::vector< aiMaterial * > *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_aiMaterial_Sm__Sg__setitem(std::vector< aiMaterial * > *self,int index,aiMaterial *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiMaterial_Sm__Sg__AddRange(std::vector< aiMaterial * > *self,std::vector< aiMaterial * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiMaterial * > *std_vector_Sl_aiMaterial_Sm__Sg__GetRange(std::vector< aiMaterial * > *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< aiMaterial * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiMaterial_Sm__Sg__Insert(std::vector< aiMaterial * > *self,int index,aiMaterial *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_aiMaterial_Sm__Sg__InsertRange(std::vector< aiMaterial * > *self,int index,std::vector< aiMaterial * > 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_aiMaterial_Sm__Sg__RemoveAt(std::vector< aiMaterial * > *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_aiMaterial_Sm__Sg__RemoveRange(std::vector< aiMaterial * > *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< aiMaterial * > *std_vector_Sl_aiMaterial_Sm__Sg__Repeat(aiMaterial *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiMaterial * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiMaterial_Sm__Sg__Reverse__SWIG_0(std::vector< aiMaterial * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiMaterial_Sm__Sg__Reverse__SWIG_1(std::vector< aiMaterial * > *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_aiMaterial_Sm__Sg__SetRange(std::vector< aiMaterial * > *self,int index,std::vector< aiMaterial * > 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_aiMaterial_Sm__Sg__Contains(std::vector< aiMaterial * > *self,aiMaterial *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiMaterial_Sm__Sg__IndexOf(std::vector< aiMaterial * > *self,aiMaterial *const &value){
        int index = -1;
        std::vector< aiMaterial * >::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_aiMaterial_Sm__Sg__LastIndexOf(std::vector< aiMaterial * > *self,aiMaterial *const &value){
        int index = -1;
        std::vector< aiMaterial * >::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_aiMaterial_Sm__Sg__Remove(std::vector< aiMaterial * > *self,aiMaterial *const &value){
        std::vector< aiMaterial * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiMeshAnim * > *new_std_vector_Sl_aiMeshAnim_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiMeshAnim * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiMeshAnim * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiMeshAnim *std_vector_Sl_aiMeshAnim_Sm__Sg__getitemcopy(std::vector< aiMeshAnim * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiMeshAnim * >::const_reference std_vector_Sl_aiMeshAnim_Sm__Sg__getitem(std::vector< aiMeshAnim * > *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_aiMeshAnim_Sm__Sg__setitem(std::vector< aiMeshAnim * > *self,int index,aiMeshAnim *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiMeshAnim_Sm__Sg__AddRange(std::vector< aiMeshAnim * > *self,std::vector< aiMeshAnim * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiMeshAnim * > *std_vector_Sl_aiMeshAnim_Sm__Sg__GetRange(std::vector< aiMeshAnim * > *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< aiMeshAnim * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiMeshAnim_Sm__Sg__Insert(std::vector< aiMeshAnim * > *self,int index,aiMeshAnim *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_aiMeshAnim_Sm__Sg__InsertRange(std::vector< aiMeshAnim * > *self,int index,std::vector< aiMeshAnim * > 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_aiMeshAnim_Sm__Sg__RemoveAt(std::vector< aiMeshAnim * > *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_aiMeshAnim_Sm__Sg__RemoveRange(std::vector< aiMeshAnim * > *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< aiMeshAnim * > *std_vector_Sl_aiMeshAnim_Sm__Sg__Repeat(aiMeshAnim *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiMeshAnim * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiMeshAnim_Sm__Sg__Reverse__SWIG_0(std::vector< aiMeshAnim * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiMeshAnim_Sm__Sg__Reverse__SWIG_1(std::vector< aiMeshAnim * > *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_aiMeshAnim_Sm__Sg__SetRange(std::vector< aiMeshAnim * > *self,int index,std::vector< aiMeshAnim * > 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_aiMeshAnim_Sm__Sg__Contains(std::vector< aiMeshAnim * > *self,aiMeshAnim *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiMeshAnim_Sm__Sg__IndexOf(std::vector< aiMeshAnim * > *self,aiMeshAnim *const &value){
        int index = -1;
        std::vector< aiMeshAnim * >::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_aiMeshAnim_Sm__Sg__LastIndexOf(std::vector< aiMeshAnim * > *self,aiMeshAnim *const &value){
        int index = -1;
        std::vector< aiMeshAnim * >::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_aiMeshAnim_Sm__Sg__Remove(std::vector< aiMeshAnim * > *self,aiMeshAnim *const &value){
        std::vector< aiMeshAnim * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiMeshKey * > *new_std_vector_Sl_aiMeshKey_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiMeshKey * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiMeshKey * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiMeshKey *std_vector_Sl_aiMeshKey_Sm__Sg__getitemcopy(std::vector< aiMeshKey * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiMeshKey * >::const_reference std_vector_Sl_aiMeshKey_Sm__Sg__getitem(std::vector< aiMeshKey * > *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_aiMeshKey_Sm__Sg__setitem(std::vector< aiMeshKey * > *self,int index,aiMeshKey *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiMeshKey_Sm__Sg__AddRange(std::vector< aiMeshKey * > *self,std::vector< aiMeshKey * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiMeshKey * > *std_vector_Sl_aiMeshKey_Sm__Sg__GetRange(std::vector< aiMeshKey * > *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< aiMeshKey * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiMeshKey_Sm__Sg__Insert(std::vector< aiMeshKey * > *self,int index,aiMeshKey *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_aiMeshKey_Sm__Sg__InsertRange(std::vector< aiMeshKey * > *self,int index,std::vector< aiMeshKey * > 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_aiMeshKey_Sm__Sg__RemoveAt(std::vector< aiMeshKey * > *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_aiMeshKey_Sm__Sg__RemoveRange(std::vector< aiMeshKey * > *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< aiMeshKey * > *std_vector_Sl_aiMeshKey_Sm__Sg__Repeat(aiMeshKey *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiMeshKey * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiMeshKey_Sm__Sg__Reverse__SWIG_0(std::vector< aiMeshKey * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiMeshKey_Sm__Sg__Reverse__SWIG_1(std::vector< aiMeshKey * > *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_aiMeshKey_Sm__Sg__SetRange(std::vector< aiMeshKey * > *self,int index,std::vector< aiMeshKey * > 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_aiMeshKey_Sm__Sg__Contains(std::vector< aiMeshKey * > *self,aiMeshKey *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiMeshKey_Sm__Sg__IndexOf(std::vector< aiMeshKey * > *self,aiMeshKey *const &value){
        int index = -1;
        std::vector< aiMeshKey * >::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_aiMeshKey_Sm__Sg__LastIndexOf(std::vector< aiMeshKey * > *self,aiMeshKey *const &value){
        int index = -1;
        std::vector< aiMeshKey * >::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_aiMeshKey_Sm__Sg__Remove(std::vector< aiMeshKey * > *self,aiMeshKey *const &value){
        std::vector< aiMeshKey * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiMesh * > *new_std_vector_Sl_aiMesh_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiMesh * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiMesh * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiMesh *std_vector_Sl_aiMesh_Sm__Sg__getitemcopy(std::vector< aiMesh * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiMesh * >::const_reference std_vector_Sl_aiMesh_Sm__Sg__getitem(std::vector< aiMesh * > *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_aiMesh_Sm__Sg__setitem(std::vector< aiMesh * > *self,int index,aiMesh *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiMesh_Sm__Sg__AddRange(std::vector< aiMesh * > *self,std::vector< aiMesh * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiMesh * > *std_vector_Sl_aiMesh_Sm__Sg__GetRange(std::vector< aiMesh * > *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< aiMesh * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiMesh_Sm__Sg__Insert(std::vector< aiMesh * > *self,int index,aiMesh *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_aiMesh_Sm__Sg__InsertRange(std::vector< aiMesh * > *self,int index,std::vector< aiMesh * > 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_aiMesh_Sm__Sg__RemoveAt(std::vector< aiMesh * > *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_aiMesh_Sm__Sg__RemoveRange(std::vector< aiMesh * > *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< aiMesh * > *std_vector_Sl_aiMesh_Sm__Sg__Repeat(aiMesh *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiMesh * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiMesh_Sm__Sg__Reverse__SWIG_0(std::vector< aiMesh * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiMesh_Sm__Sg__Reverse__SWIG_1(std::vector< aiMesh * > *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_aiMesh_Sm__Sg__SetRange(std::vector< aiMesh * > *self,int index,std::vector< aiMesh * > 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_aiMesh_Sm__Sg__Contains(std::vector< aiMesh * > *self,aiMesh *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiMesh_Sm__Sg__IndexOf(std::vector< aiMesh * > *self,aiMesh *const &value){
        int index = -1;
        std::vector< aiMesh * >::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_aiMesh_Sm__Sg__LastIndexOf(std::vector< aiMesh * > *self,aiMesh *const &value){
        int index = -1;
        std::vector< aiMesh * >::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_aiMesh_Sm__Sg__Remove(std::vector< aiMesh * > *self,aiMesh *const &value){
        std::vector< aiMesh * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiNode * > *new_std_vector_Sl_aiNode_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiNode * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiNode * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiNode *std_vector_Sl_aiNode_Sm__Sg__getitemcopy(std::vector< aiNode * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiNode * >::const_reference std_vector_Sl_aiNode_Sm__Sg__getitem(std::vector< aiNode * > *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_aiNode_Sm__Sg__setitem(std::vector< aiNode * > *self,int index,aiNode *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiNode_Sm__Sg__AddRange(std::vector< aiNode * > *self,std::vector< aiNode * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiNode * > *std_vector_Sl_aiNode_Sm__Sg__GetRange(std::vector< aiNode * > *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< aiNode * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiNode_Sm__Sg__Insert(std::vector< aiNode * > *self,int index,aiNode *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_aiNode_Sm__Sg__InsertRange(std::vector< aiNode * > *self,int index,std::vector< aiNode * > 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_aiNode_Sm__Sg__RemoveAt(std::vector< aiNode * > *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_aiNode_Sm__Sg__RemoveRange(std::vector< aiNode * > *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< aiNode * > *std_vector_Sl_aiNode_Sm__Sg__Repeat(aiNode *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiNode * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiNode_Sm__Sg__Reverse__SWIG_0(std::vector< aiNode * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiNode_Sm__Sg__Reverse__SWIG_1(std::vector< aiNode * > *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_aiNode_Sm__Sg__SetRange(std::vector< aiNode * > *self,int index,std::vector< aiNode * > 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_aiNode_Sm__Sg__Contains(std::vector< aiNode * > *self,aiNode *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiNode_Sm__Sg__IndexOf(std::vector< aiNode * > *self,aiNode *const &value){
        int index = -1;
        std::vector< aiNode * >::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_aiNode_Sm__Sg__LastIndexOf(std::vector< aiNode * > *self,aiNode *const &value){
        int index = -1;
        std::vector< aiNode * >::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_aiNode_Sm__Sg__Remove(std::vector< aiNode * > *self,aiNode *const &value){
        std::vector< aiNode * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiNodeAnim * > *new_std_vector_Sl_aiNodeAnim_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiNodeAnim * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiNodeAnim * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiNodeAnim *std_vector_Sl_aiNodeAnim_Sm__Sg__getitemcopy(std::vector< aiNodeAnim * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiNodeAnim * >::const_reference std_vector_Sl_aiNodeAnim_Sm__Sg__getitem(std::vector< aiNodeAnim * > *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_aiNodeAnim_Sm__Sg__setitem(std::vector< aiNodeAnim * > *self,int index,aiNodeAnim *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiNodeAnim_Sm__Sg__AddRange(std::vector< aiNodeAnim * > *self,std::vector< aiNodeAnim * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiNodeAnim * > *std_vector_Sl_aiNodeAnim_Sm__Sg__GetRange(std::vector< aiNodeAnim * > *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< aiNodeAnim * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiNodeAnim_Sm__Sg__Insert(std::vector< aiNodeAnim * > *self,int index,aiNodeAnim *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_aiNodeAnim_Sm__Sg__InsertRange(std::vector< aiNodeAnim * > *self,int index,std::vector< aiNodeAnim * > 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_aiNodeAnim_Sm__Sg__RemoveAt(std::vector< aiNodeAnim * > *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_aiNodeAnim_Sm__Sg__RemoveRange(std::vector< aiNodeAnim * > *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< aiNodeAnim * > *std_vector_Sl_aiNodeAnim_Sm__Sg__Repeat(aiNodeAnim *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiNodeAnim * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiNodeAnim_Sm__Sg__Reverse__SWIG_0(std::vector< aiNodeAnim * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiNodeAnim_Sm__Sg__Reverse__SWIG_1(std::vector< aiNodeAnim * > *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_aiNodeAnim_Sm__Sg__SetRange(std::vector< aiNodeAnim * > *self,int index,std::vector< aiNodeAnim * > 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_aiNodeAnim_Sm__Sg__Contains(std::vector< aiNodeAnim * > *self,aiNodeAnim *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiNodeAnim_Sm__Sg__IndexOf(std::vector< aiNodeAnim * > *self,aiNodeAnim *const &value){
        int index = -1;
        std::vector< aiNodeAnim * >::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_aiNodeAnim_Sm__Sg__LastIndexOf(std::vector< aiNodeAnim * > *self,aiNodeAnim *const &value){
        int index = -1;
        std::vector< aiNodeAnim * >::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_aiNodeAnim_Sm__Sg__Remove(std::vector< aiNodeAnim * > *self,aiNodeAnim *const &value){
        std::vector< aiNodeAnim * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiQuatKey * > *new_std_vector_Sl_aiQuatKey_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiQuatKey * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiQuatKey * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiQuatKey *std_vector_Sl_aiQuatKey_Sm__Sg__getitemcopy(std::vector< aiQuatKey * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiQuatKey * >::const_reference std_vector_Sl_aiQuatKey_Sm__Sg__getitem(std::vector< aiQuatKey * > *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_aiQuatKey_Sm__Sg__setitem(std::vector< aiQuatKey * > *self,int index,aiQuatKey *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiQuatKey_Sm__Sg__AddRange(std::vector< aiQuatKey * > *self,std::vector< aiQuatKey * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiQuatKey * > *std_vector_Sl_aiQuatKey_Sm__Sg__GetRange(std::vector< aiQuatKey * > *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< aiQuatKey * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiQuatKey_Sm__Sg__Insert(std::vector< aiQuatKey * > *self,int index,aiQuatKey *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_aiQuatKey_Sm__Sg__InsertRange(std::vector< aiQuatKey * > *self,int index,std::vector< aiQuatKey * > 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_aiQuatKey_Sm__Sg__RemoveAt(std::vector< aiQuatKey * > *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_aiQuatKey_Sm__Sg__RemoveRange(std::vector< aiQuatKey * > *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< aiQuatKey * > *std_vector_Sl_aiQuatKey_Sm__Sg__Repeat(aiQuatKey *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiQuatKey * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiQuatKey_Sm__Sg__Reverse__SWIG_0(std::vector< aiQuatKey * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiQuatKey_Sm__Sg__Reverse__SWIG_1(std::vector< aiQuatKey * > *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_aiQuatKey_Sm__Sg__SetRange(std::vector< aiQuatKey * > *self,int index,std::vector< aiQuatKey * > 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_aiQuatKey_Sm__Sg__Contains(std::vector< aiQuatKey * > *self,aiQuatKey *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiQuatKey_Sm__Sg__IndexOf(std::vector< aiQuatKey * > *self,aiQuatKey *const &value){
        int index = -1;
        std::vector< aiQuatKey * >::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_aiQuatKey_Sm__Sg__LastIndexOf(std::vector< aiQuatKey * > *self,aiQuatKey *const &value){
        int index = -1;
        std::vector< aiQuatKey * >::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_aiQuatKey_Sm__Sg__Remove(std::vector< aiQuatKey * > *self,aiQuatKey *const &value){
        std::vector< aiQuatKey * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiTexture * > *new_std_vector_Sl_aiTexture_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiTexture * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiTexture * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiTexture *std_vector_Sl_aiTexture_Sm__Sg__getitemcopy(std::vector< aiTexture * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiTexture * >::const_reference std_vector_Sl_aiTexture_Sm__Sg__getitem(std::vector< aiTexture * > *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_aiTexture_Sm__Sg__setitem(std::vector< aiTexture * > *self,int index,aiTexture *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiTexture_Sm__Sg__AddRange(std::vector< aiTexture * > *self,std::vector< aiTexture * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiTexture * > *std_vector_Sl_aiTexture_Sm__Sg__GetRange(std::vector< aiTexture * > *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< aiTexture * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiTexture_Sm__Sg__Insert(std::vector< aiTexture * > *self,int index,aiTexture *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_aiTexture_Sm__Sg__InsertRange(std::vector< aiTexture * > *self,int index,std::vector< aiTexture * > 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_aiTexture_Sm__Sg__RemoveAt(std::vector< aiTexture * > *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_aiTexture_Sm__Sg__RemoveRange(std::vector< aiTexture * > *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< aiTexture * > *std_vector_Sl_aiTexture_Sm__Sg__Repeat(aiTexture *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiTexture * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiTexture_Sm__Sg__Reverse__SWIG_0(std::vector< aiTexture * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiTexture_Sm__Sg__Reverse__SWIG_1(std::vector< aiTexture * > *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_aiTexture_Sm__Sg__SetRange(std::vector< aiTexture * > *self,int index,std::vector< aiTexture * > 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_aiTexture_Sm__Sg__Contains(std::vector< aiTexture * > *self,aiTexture *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiTexture_Sm__Sg__IndexOf(std::vector< aiTexture * > *self,aiTexture *const &value){
        int index = -1;
        std::vector< aiTexture * >::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_aiTexture_Sm__Sg__LastIndexOf(std::vector< aiTexture * > *self,aiTexture *const &value){
        int index = -1;
        std::vector< aiTexture * >::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_aiTexture_Sm__Sg__Remove(std::vector< aiTexture * > *self,aiTexture *const &value){
        std::vector< aiTexture * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiVector3D * > *new_std_vector_Sl_aiVector3D_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiVector3D * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiVector3D * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiVector3D *std_vector_Sl_aiVector3D_Sm__Sg__getitemcopy(std::vector< aiVector3D * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiVector3D * >::const_reference std_vector_Sl_aiVector3D_Sm__Sg__getitem(std::vector< aiVector3D * > *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_aiVector3D_Sm__Sg__setitem(std::vector< aiVector3D * > *self,int index,aiVector3D *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__AddRange(std::vector< aiVector3D * > *self,std::vector< aiVector3D * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiVector3D * > *std_vector_Sl_aiVector3D_Sm__Sg__GetRange(std::vector< aiVector3D * > *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< aiVector3D * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Insert(std::vector< aiVector3D * > *self,int index,aiVector3D *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_aiVector3D_Sm__Sg__InsertRange(std::vector< aiVector3D * > *self,int index,std::vector< aiVector3D * > 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_aiVector3D_Sm__Sg__RemoveAt(std::vector< aiVector3D * > *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_aiVector3D_Sm__Sg__RemoveRange(std::vector< aiVector3D * > *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< aiVector3D * > *std_vector_Sl_aiVector3D_Sm__Sg__Repeat(aiVector3D *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiVector3D * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Reverse__SWIG_0(std::vector< aiVector3D * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Reverse__SWIG_1(std::vector< aiVector3D * > *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_aiVector3D_Sm__Sg__SetRange(std::vector< aiVector3D * > *self,int index,std::vector< aiVector3D * > 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_aiVector3D_Sm__Sg__Contains(std::vector< aiVector3D * > *self,aiVector3D *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiVector3D_Sm__Sg__IndexOf(std::vector< aiVector3D * > *self,aiVector3D *const &value){
        int index = -1;
        std::vector< aiVector3D * >::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_aiVector3D_Sm__Sg__LastIndexOf(std::vector< aiVector3D * > *self,aiVector3D *const &value){
        int index = -1;
        std::vector< aiVector3D * >::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_aiVector3D_Sm__Sg__Remove(std::vector< aiVector3D * > *self,aiVector3D *const &value){
        std::vector< aiVector3D * >::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< aiVector3D * > > *new_std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< aiVector3D * > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< aiVector3D * > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< aiVector3D * > std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__getitemcopy(std::vector< std::vector< aiVector3D * > > *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< aiVector3D * > >::const_reference std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__getitem(std::vector< std::vector< aiVector3D * > > *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_aiVector3D_Sm__Sg__Sg__setitem(std::vector< std::vector< aiVector3D * > > *self,int index,std::vector< aiVector3D * > 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_aiVector3D_Sm__Sg__Sg__AddRange(std::vector< std::vector< aiVector3D * > > *self,std::vector< std::vector< aiVector3D * > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< aiVector3D * > > *std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__GetRange(std::vector< std::vector< aiVector3D * > > *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< aiVector3D * > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Insert(std::vector< std::vector< aiVector3D * > > *self,int index,std::vector< aiVector3D * > 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_aiVector3D_Sm__Sg__Sg__InsertRange(std::vector< std::vector< aiVector3D * > > *self,int index,std::vector< std::vector< aiVector3D * > > 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_aiVector3D_Sm__Sg__Sg__RemoveAt(std::vector< std::vector< aiVector3D * > > *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_aiVector3D_Sm__Sg__Sg__RemoveRange(std::vector< std::vector< aiVector3D * > > *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< aiVector3D * > > *std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Repeat(std::vector< aiVector3D * > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< aiVector3D * > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< aiVector3D * > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< aiVector3D * > > *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_aiVector3D_Sm__Sg__Sg__SetRange(std::vector< std::vector< aiVector3D * > > *self,int index,std::vector< std::vector< aiVector3D * > > 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< aiVectorKey * > *new_std_vector_Sl_aiVectorKey_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiVectorKey * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiVectorKey * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiVectorKey *std_vector_Sl_aiVectorKey_Sm__Sg__getitemcopy(std::vector< aiVectorKey * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiVectorKey * >::const_reference std_vector_Sl_aiVectorKey_Sm__Sg__getitem(std::vector< aiVectorKey * > *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_aiVectorKey_Sm__Sg__setitem(std::vector< aiVectorKey * > *self,int index,aiVectorKey *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiVectorKey_Sm__Sg__AddRange(std::vector< aiVectorKey * > *self,std::vector< aiVectorKey * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiVectorKey * > *std_vector_Sl_aiVectorKey_Sm__Sg__GetRange(std::vector< aiVectorKey * > *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< aiVectorKey * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiVectorKey_Sm__Sg__Insert(std::vector< aiVectorKey * > *self,int index,aiVectorKey *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_aiVectorKey_Sm__Sg__InsertRange(std::vector< aiVectorKey * > *self,int index,std::vector< aiVectorKey * > 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_aiVectorKey_Sm__Sg__RemoveAt(std::vector< aiVectorKey * > *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_aiVectorKey_Sm__Sg__RemoveRange(std::vector< aiVectorKey * > *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< aiVectorKey * > *std_vector_Sl_aiVectorKey_Sm__Sg__Repeat(aiVectorKey *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiVectorKey * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiVectorKey_Sm__Sg__Reverse__SWIG_0(std::vector< aiVectorKey * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiVectorKey_Sm__Sg__Reverse__SWIG_1(std::vector< aiVectorKey * > *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_aiVectorKey_Sm__Sg__SetRange(std::vector< aiVectorKey * > *self,int index,std::vector< aiVectorKey * > 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_aiVectorKey_Sm__Sg__Contains(std::vector< aiVectorKey * > *self,aiVectorKey *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiVectorKey_Sm__Sg__IndexOf(std::vector< aiVectorKey * > *self,aiVectorKey *const &value){
        int index = -1;
        std::vector< aiVectorKey * >::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_aiVectorKey_Sm__Sg__LastIndexOf(std::vector< aiVectorKey * > *self,aiVectorKey *const &value){
        int index = -1;
        std::vector< aiVectorKey * >::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_aiVectorKey_Sm__Sg__Remove(std::vector< aiVectorKey * > *self,aiVectorKey *const &value){
        std::vector< aiVectorKey * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< aiVertexWeight * > *new_std_vector_Sl_aiVertexWeight_Sm__Sg___SWIG_2(int capacity){
        std::vector< aiVertexWeight * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< aiVertexWeight * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN aiVertexWeight *std_vector_Sl_aiVertexWeight_Sm__Sg__getitemcopy(std::vector< aiVertexWeight * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< aiVertexWeight * >::const_reference std_vector_Sl_aiVertexWeight_Sm__Sg__getitem(std::vector< aiVertexWeight * > *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_aiVertexWeight_Sm__Sg__setitem(std::vector< aiVertexWeight * > *self,int index,aiVertexWeight *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_aiVertexWeight_Sm__Sg__AddRange(std::vector< aiVertexWeight * > *self,std::vector< aiVertexWeight * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< aiVertexWeight * > *std_vector_Sl_aiVertexWeight_Sm__Sg__GetRange(std::vector< aiVertexWeight * > *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< aiVertexWeight * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_aiVertexWeight_Sm__Sg__Insert(std::vector< aiVertexWeight * > *self,int index,aiVertexWeight *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_aiVertexWeight_Sm__Sg__InsertRange(std::vector< aiVertexWeight * > *self,int index,std::vector< aiVertexWeight * > 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_aiVertexWeight_Sm__Sg__RemoveAt(std::vector< aiVertexWeight * > *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_aiVertexWeight_Sm__Sg__RemoveRange(std::vector< aiVertexWeight * > *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< aiVertexWeight * > *std_vector_Sl_aiVertexWeight_Sm__Sg__Repeat(aiVertexWeight *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< aiVertexWeight * >(count, value);
      }
SWIGINTERN void std_vector_Sl_aiVertexWeight_Sm__Sg__Reverse__SWIG_0(std::vector< aiVertexWeight * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_aiVertexWeight_Sm__Sg__Reverse__SWIG_1(std::vector< aiVertexWeight * > *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_aiVertexWeight_Sm__Sg__SetRange(std::vector< aiVertexWeight * > *self,int index,std::vector< aiVertexWeight * > 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_aiVertexWeight_Sm__Sg__Contains(std::vector< aiVertexWeight * > *self,aiVertexWeight *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_aiVertexWeight_Sm__Sg__IndexOf(std::vector< aiVertexWeight * > *self,aiVertexWeight *const &value){
        int index = -1;
        std::vector< aiVertexWeight * >::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_aiVertexWeight_Sm__Sg__LastIndexOf(std::vector< aiVertexWeight * > *self,aiVertexWeight *const &value){
        int index = -1;
        std::vector< aiVertexWeight * >::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_aiVertexWeight_Sm__Sg__Remove(std::vector< aiVertexWeight * > *self,aiVertexWeight *const &value){
        std::vector< aiVertexWeight * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT double SWIGSTDCALL CSharp_AI_MATH_PI_get() {
  double jresult ;
  double result;
  
  result = (double)((3.141592653589793238462643383279));
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_AI_MATH_TWO_PI_get() {
  double jresult ;
  double result;
  
  result = (double)(((3.141592653589793238462643383279)*2.0));
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_AI_MATH_HALF_PI_get() {
  double jresult ;
  double result;
  
  result = (double)(((3.141592653589793238462643383279)*0.5));
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_AI_MATH_PI_F_get() {
  double jresult ;
  double result;
  
  result = (double)((3.1415926538));
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_AI_MATH_TWO_PI_F_get() {
  double jresult ;
  double result;
  
  result = (double)(((3.1415926538)*2.0));
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_AI_MATH_HALF_PI_F_get() {
  double jresult ;
  double result;
  
  result = (double)(((3.1415926538)*0.5));
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_GLOB_MEASURE_TIME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("GLOB_MEASURE_TIME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_CT_MAX_SMOOTHING_ANGLE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_GSN_MAX_SMOOTHING_ANGLE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MDL_COLORMAP_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MDL_COLORMAP");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_RRM_EXCLUDE_LIST_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_RRM_EXCLUDE_LIST");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_PTV_KEEP_HIERARCHY_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_PTV_KEEP_HIERARCHY");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_PTV_NORMALIZE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_PTV_NORMALIZE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_FD_REMOVE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_FD_REMOVE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_OG_EXCLUDE_LIST_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_OG_EXCLUDE_LIST");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_SLM_TRIANGLE_LIMIT_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_SLM_TRIANGLE_LIMIT");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SLM_DEFAULT_MAX_TRIANGLES_get() {
  int jresult ;
  int result;
  
  result = (int)(1000000);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_SLM_VERTEX_LIMIT_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_SLM_VERTEX_LIMIT");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SLM_DEFAULT_MAX_VERTICES_get() {
  int jresult ;
  int result;
  
  result = (int)(1000000);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_LBW_MAX_WEIGHTS_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_LBW_MAX_WEIGHTS");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_LMW_MAX_WEIGHTS_get() {
  int jresult ;
  int result;
  
  result = (int)(0x4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_PP_ICL_PTCACHE_SIZE_get() {
  int jresult ;
  int result;
  
  result = (int)(12);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_ICL_PTCACHE_SIZE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_ICL_PTCACHE_SIZE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_RVC_FLAGS_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_RVC_FLAGS");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_SBP_REMOVE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_SBP_REMOVE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_FID_ANIM_ACCURACY_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_FID_ANIM_ACCURACY");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_UVTRAFO_SCALING_get() {
  int jresult ;
  int result;
  
  result = (int)(0x1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_UVTRAFO_ROTATION_get() {
  int jresult ;
  int result;
  
  result = (int)(0x2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_UVTRAFO_TRANSLATION_get() {
  int jresult ;
  int result;
  
  result = (int)(0x4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_UVTRAFO_ALL_get() {
  int jresult ;
  int result;
  
  result = (int)((0x1|0x2|0x4));
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_TUV_EVALUATE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PP_TUV_EVALUATE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_FAVOUR_SPEED_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("FAVOUR_SPEED");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_GLOBAL_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_GLOBAL_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MD3_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MD3_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MD2_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MD2_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MDL_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MDL_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MDC_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MDC_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_SMD_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_SMD_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_UNREAL_KEYFRAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_UNREAL_KEYFRAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_AC_SEPARATE_BFCULL");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_AC_EVAL_SUBDIVISION");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("UNREAL_HANDLE_FLAGS");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_TER_MAKE_UVS_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_TER_MAKE_UVS");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_ASE_RECONSTRUCT_NORMALS");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MD3_HANDLE_MULTIPART");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MD3_SKIN_NAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MD3_SKIN_NAME");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MD3_SHADER_SRC_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MD3_SHADER_SRC");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_LWO_ONE_LAYER_ONLY");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_MD5_NO_ANIM_AUTOLOAD");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_LWS_ANIM_START_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_LWS_ANIM_START");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_LWS_ANIM_END_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_LWS_ANIM_END");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_IRR_ANIM_FPS_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_IRR_ANIM_FPS");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("IMPORT_OGRE_MATERIAL_FILE");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_MAXLEN_get() {
  unsigned long jresult ;
  size_t result;
  
  result = (size_t)MAXLEN;
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiPlane__SWIG_0() {
  void * jresult ;
  aiPlane *result = 0 ;
  
  result = (aiPlane *)new aiPlane();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiPlane__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  aiPlane *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  result = (aiPlane *)new aiPlane(arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiPlane__SWIG_2(void * jarg1) {
  void * jresult ;
  aiPlane *arg1 = 0 ;
  aiPlane *result = 0 ;
  
  arg1 = (aiPlane *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiPlane const & type is null", 0);
    return 0;
  } 
  result = (aiPlane *)new aiPlane((aiPlane const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiPlane_a_set(void * jarg1, float jarg2) {
  aiPlane *arg1 = (aiPlane *) 0 ;
  float arg2 ;
  
  arg1 = (aiPlane *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiPlane_a_get(void * jarg1) {
  float jresult ;
  aiPlane *arg1 = (aiPlane *) 0 ;
  float result;
  
  arg1 = (aiPlane *)jarg1; 
  result = (float) ((arg1)->a);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiPlane_b_set(void * jarg1, float jarg2) {
  aiPlane *arg1 = (aiPlane *) 0 ;
  float arg2 ;
  
  arg1 = (aiPlane *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiPlane_b_get(void * jarg1) {
  float jresult ;
  aiPlane *arg1 = (aiPlane *) 0 ;
  float result;
  
  arg1 = (aiPlane *)jarg1; 
  result = (float) ((arg1)->b);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiPlane_c_set(void * jarg1, float jarg2) {
  aiPlane *arg1 = (aiPlane *) 0 ;
  float arg2 ;
  
  arg1 = (aiPlane *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiPlane_c_get(void * jarg1) {
  float jresult ;
  aiPlane *arg1 = (aiPlane *) 0 ;
  float result;
  
  arg1 = (aiPlane *)jarg1; 
  result = (float) ((arg1)->c);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiPlane_d_set(void * jarg1, float jarg2) {
  aiPlane *arg1 = (aiPlane *) 0 ;
  float arg2 ;
  
  arg1 = (aiPlane *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->d = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiPlane_d_get(void * jarg1) {
  float jresult ;
  aiPlane *arg1 = (aiPlane *) 0 ;
  float result;
  
  arg1 = (aiPlane *)jarg1; 
  result = (float) ((arg1)->d);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiPlane(void * jarg1) {
  aiPlane *arg1 = (aiPlane *) 0 ;
  
  arg1 = (aiPlane *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiRay__SWIG_0() {
  void * jresult ;
  aiRay *result = 0 ;
  
  result = (aiRay *)new aiRay();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiRay__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = 0 ;
  aiVector3D *arg2 = 0 ;
  aiRay *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (aiRay *)new aiRay((aiVector3D const &)*arg1,(aiVector3D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiRay__SWIG_2(void * jarg1) {
  void * jresult ;
  aiRay *arg1 = 0 ;
  aiRay *result = 0 ;
  
  arg1 = (aiRay *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiRay const & type is null", 0);
    return 0;
  } 
  result = (aiRay *)new aiRay((aiRay const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiRay_pos_set(void * jarg1, void * jarg2) {
  aiRay *arg1 = (aiRay *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiRay *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->pos = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiRay_pos_get(void * jarg1) {
  void * jresult ;
  aiRay *arg1 = (aiRay *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiRay *)jarg1; 
  result = (aiVector3D *)& ((arg1)->pos);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiRay_dir_set(void * jarg1, void * jarg2) {
  aiRay *arg1 = (aiRay *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiRay *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiRay_dir_get(void * jarg1) {
  void * jresult ;
  aiRay *arg1 = (aiRay *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiRay *)jarg1; 
  result = (aiVector3D *)& ((arg1)->dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiRay(void * jarg1) {
  aiRay *arg1 = (aiRay *) 0 ;
  
  arg1 = (aiRay *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor3D__SWIG_0() {
  void * jresult ;
  aiColor3D *result = 0 ;
  
  result = (aiColor3D *)new aiColor3D();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor3D__SWIG_1(float jarg1, float jarg2, float jarg3) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  aiColor3D *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  result = (aiColor3D *)new aiColor3D(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor3D__SWIG_2(float jarg1) {
  void * jresult ;
  float arg1 ;
  aiColor3D *result = 0 ;
  
  arg1 = (float)jarg1; 
  result = (aiColor3D *)new aiColor3D(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor3D__SWIG_3(void * jarg1) {
  void * jresult ;
  aiColor3D *arg1 = 0 ;
  aiColor3D *result = 0 ;
  
  arg1 = (aiColor3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor3D const & type is null", 0);
    return 0;
  } 
  result = (aiColor3D *)new aiColor3D((aiColor3D const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor3D___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  aiColor3D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (aiColor3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor3D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiColor3D const *)arg1)->operator ==((aiColor3D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor3D___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  aiColor3D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (aiColor3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor3D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiColor3D const *)arg1)->operator !=((aiColor3D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor3D___add__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  aiColor3D *arg2 = 0 ;
  aiColor3D result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (aiColor3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor3D const & type is null", 0);
    return 0;
  } 
  result = ((aiColor3D const *)arg1)->operator +((aiColor3D const &)*arg2);
  jresult = new aiColor3D((const aiColor3D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor3D___sub__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  aiColor3D *arg2 = 0 ;
  aiColor3D result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (aiColor3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor3D const & type is null", 0);
    return 0;
  } 
  result = ((aiColor3D const *)arg1)->operator -((aiColor3D const &)*arg2);
  jresult = new aiColor3D((const aiColor3D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor3D___mul____SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  aiColor3D *arg2 = 0 ;
  aiColor3D result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (aiColor3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor3D const & type is null", 0);
    return 0;
  } 
  result = ((aiColor3D const *)arg1)->operator *((aiColor3D const &)*arg2);
  jresult = new aiColor3D((const aiColor3D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor3D___mul____SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float arg2 ;
  aiColor3D result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (float)jarg2; 
  result = ((aiColor3D const *)arg1)->operator *(arg2);
  jresult = new aiColor3D((const aiColor3D &)result); 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor3D___idx____SWIG_0(void * jarg1, unsigned int jarg2) {
  float jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  unsigned int arg2 ;
  float result;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (float)((aiColor3D const *)arg1)->operator [](arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor3D_IsBlack(void * jarg1) {
  unsigned int jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  bool result;
  
  arg1 = (aiColor3D *)jarg1; 
  result = (bool)((aiColor3D const *)arg1)->IsBlack();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor3D_r_set(void * jarg1, float jarg2) {
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->r = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor3D_r_get(void * jarg1) {
  float jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float result;
  
  arg1 = (aiColor3D *)jarg1; 
  result = (float) ((arg1)->r);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor3D_g_set(void * jarg1, float jarg2) {
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->g = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor3D_g_get(void * jarg1) {
  float jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float result;
  
  arg1 = (aiColor3D *)jarg1; 
  result = (float) ((arg1)->g);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor3D_b_set(void * jarg1, float jarg2) {
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor3D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor3D_b_get(void * jarg1) {
  float jresult ;
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  float result;
  
  arg1 = (aiColor3D *)jarg1; 
  result = (float) ((arg1)->b);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiColor3D(void * jarg1) {
  aiColor3D *arg1 = (aiColor3D *) 0 ;
  
  arg1 = (aiColor3D *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiString__SWIG_0() {
  void * jresult ;
  aiString *result = 0 ;
  
  result = (aiString *)new aiString();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiString__SWIG_1(void * jarg1) {
  void * jresult ;
  aiString *arg1 = 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiString *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiString const & type is null", 0);
    return 0;
  } 
  result = (aiString *)new aiString((aiString const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiString__SWIG_2(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  aiString *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  result = (aiString *)new aiString((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiString___set____SWIG_0(void * jarg1, char * jarg2) {
  void * jresult ;
  aiString *arg1 = (aiString *) 0 ;
  char *arg2 = (char *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiString *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (aiString *) &(arg1)->operator =((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiString___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiString *arg1 = (aiString *) 0 ;
  aiString *arg2 = 0 ;
  bool result;
  
  arg1 = (aiString *)jarg1; 
  arg2 = (aiString *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiString const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiString const *)arg1)->operator ==((aiString const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiString___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiString *arg1 = (aiString *) 0 ;
  aiString *arg2 = 0 ;
  bool result;
  
  arg1 = (aiString *)jarg1; 
  arg2 = (aiString *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiString const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiString const *)arg1)->operator !=((aiString const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiString_Length_set(void * jarg1, unsigned long jarg2) {
  aiString *arg1 = (aiString *) 0 ;
  size_t arg2 ;
  
  arg1 = (aiString *)jarg1; 
  arg2 = (size_t)jarg2; 
  if (arg1) (arg1)->length = arg2;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiString_Length_get(void * jarg1) {
  unsigned long jresult ;
  aiString *arg1 = (aiString *) 0 ;
  size_t result;
  
  arg1 = (aiString *)jarg1; 
  result =  ((arg1)->length);
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiString_Data_set(void * jarg1, char * jarg2) {
  aiString *arg1 = (aiString *) 0 ;
  char *arg2 ;
  
  arg1 = (aiString *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    if(arg2) {
      strncpy((char*)arg1->data, (const char *)arg2, MAXLEN-1);
      arg1->data[MAXLEN-1] = 0;
    } else {
      arg1->data[0] = 0;
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_aiString_Data_get(void * jarg1) {
  char * jresult ;
  aiString *arg1 = (aiString *) 0 ;
  char *result = 0 ;
  
  arg1 = (aiString *)jarg1; 
  result = (char *)(char *) ((arg1)->data);
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiString(void * jarg1) {
  aiString *arg1 = (aiString *) 0 ;
  
  arg1 = (aiString *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMemoryInfo() {
  void * jresult ;
  aiMemoryInfo *result = 0 ;
  
  result = (aiMemoryInfo *)new aiMemoryInfo();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_textures_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->textures = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_textures_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->textures);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_materials_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->materials = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_materials_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->materials);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_meshes_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->meshes = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_meshes_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->meshes);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_nodes_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->nodes = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_nodes_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->nodes);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_animations_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->animations = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_animations_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->animations);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_cameras_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->cameras = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_cameras_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->cameras);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_lights_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->lights = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_lights_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->lights);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMemoryInfo_total_set(void * jarg1, unsigned int jarg2) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->total = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMemoryInfo_total_get(void * jarg1) {
  unsigned int jresult ;
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  unsigned int result;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  result = (unsigned int) ((arg1)->total);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMemoryInfo(void * jarg1) {
  aiMemoryInfo *arg1 = (aiMemoryInfo *) 0 ;
  
  arg1 = (aiMemoryInfo *)jarg1; 
  delete arg1;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_aiGetLegalString() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)aiGetLegalString();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiGetVersionMinor() {
  unsigned int jresult ;
  unsigned int result;
  
  result = (unsigned int)aiGetVersionMinor();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiGetVersionMajor() {
  unsigned int jresult ;
  unsigned int result;
  
  result = (unsigned int)aiGetVersionMajor();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiGetVersionRevision() {
  unsigned int jresult ;
  unsigned int result;
  
  result = (unsigned int)aiGetVersionRevision();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASSIMP_CFLAGS_SHARED_get() {
  int jresult ;
  int result;
  
  result = (int)(0x1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASSIMP_CFLAGS_STLPORT_get() {
  int jresult ;
  int result;
  
  result = (int)(0x2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASSIMP_CFLAGS_DEBUG_get() {
  int jresult ;
  int result;
  
  result = (int)(0x4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASSIMP_CFLAGS_NOBOOST_get() {
  int jresult ;
  int result;
  
  result = (int)(0x8);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASSIMP_CFLAGS_SINGLETHREADED_get() {
  int jresult ;
  int result;
  
  result = (int)(0x10);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiGetCompileFlags() {
  unsigned int jresult ;
  unsigned int result;
  
  result = (unsigned int)aiGetCompileFlags();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_0() {
  void * jresult ;
  aiVector2D *result = 0 ;
  
  result = (aiVector2D *)new aiVector2D();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_1(float jarg1, float jarg2) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  aiVector2D *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVector2D *)new aiVector2D(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_2(float jarg1) {
  void * jresult ;
  float arg1 ;
  aiVector2D *result = 0 ;
  
  arg1 = (float)jarg1; 
  result = (aiVector2D *)new aiVector2D(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_3(void * jarg1) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (aiVector2D *)new aiVector2D((aiVector2D const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_Set(void * jarg1, float jarg2, float jarg3) {
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float arg2 ;
  float arg3 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  (arg1)->Set(arg2,arg3);
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_SquareLength(void * jarg1) {
  float jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float result;
  
  arg1 = (aiVector2D *)jarg1; 
  result = (float)((aiVector2D const *)arg1)->SquareLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_Length(void * jarg1) {
  float jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float result;
  
  arg1 = (aiVector2D *)jarg1; 
  result = (float)((aiVector2D const *)arg1)->Length();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D_Normalize(void * jarg1) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  result = (aiVector2D *) &(arg1)->Normalize();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___addnset__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (aiVector2D *) &(arg1)->operator +=((aiVector2D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___subnset__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (aiVector2D *) &(arg1)->operator -=((aiVector2D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___mulnset__(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float arg2 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVector2D *) &(arg1)->operator *=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___divnset__(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float arg2 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVector2D *) &(arg1)->operator /=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D___idx____SWIG_0(void * jarg1, unsigned int jarg2) {
  float jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  unsigned int arg2 ;
  float result;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (float)((aiVector2D const *)arg1)->operator [](arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector2D___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  aiVector2D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVector2D const *)arg1)->operator ==((aiVector2D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector2D___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  aiVector2D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVector2D const *)arg1)->operator !=((aiVector2D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___set__(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float arg2 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVector2D *) &(arg1)->operator =(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D_SymMul(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (arg1)->SymMul((aiVector2D const &)*arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_x_set(void * jarg1, float jarg2) {
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float arg2 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_x_get(void * jarg1) {
  float jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float result;
  
  arg1 = (aiVector2D *)jarg1; 
  result = (float) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_y_set(void * jarg1, float jarg2) {
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float arg2 ;
  
  arg1 = (aiVector2D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_y_get(void * jarg1) {
  float jresult ;
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  float result;
  
  arg1 = (aiVector2D *)jarg1; 
  result = (float) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector2D(void * jarg1) {
  aiVector2D *arg1 = (aiVector2D *) 0 ;
  
  arg1 = (aiVector2D *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___add__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = operator +((aiVector2D const &)*arg1,(aiVector2D const &)*arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___sub____SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = operator -((aiVector2D const &)*arg1,(aiVector2D const &)*arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp___mul____SWIG_0(void * jarg1, void * jarg2) {
  float jresult ;
  aiVector2D *arg1 = 0 ;
  aiVector2D *arg2 = 0 ;
  float result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = (float)operator *((aiVector2D const &)*arg1,(aiVector2D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___mul____SWIG_1(float jarg1, void * jarg2) {
  void * jresult ;
  float arg1 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D result;
  
  arg1 = (float)jarg1; 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = operator *(arg1,(aiVector2D const &)*arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___mul____SWIG_2(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  float arg2 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (float)jarg2; 
  result = operator *((aiVector2D const &)*arg1,arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___div____SWIG_0(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  float arg2 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (float)jarg2; 
  result = operator /((aiVector2D const &)*arg1,arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___div____SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  aiVector2D *arg2 = 0 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector2D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = operator /((aiVector2D const &)*arg1,(aiVector2D const &)*arg2);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp___sub____SWIG_1(void * jarg1) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  aiVector2D result;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  result = operator -((aiVector2D const &)*arg1);
  jresult = new aiVector2D((const aiVector2D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_0() {
  void * jresult ;
  aiVector3D *result = 0 ;
  
  result = (aiVector3D *)new aiVector3D();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_1(float jarg1, float jarg2, float jarg3) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  aiVector3D *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  result = (aiVector3D *)new aiVector3D(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_2(float jarg1) {
  void * jresult ;
  float arg1 ;
  aiVector3D *result = 0 ;
  
  arg1 = (float)jarg1; 
  result = (aiVector3D *)new aiVector3D(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_3(void * jarg1) {
  void * jresult ;
  aiVector3D *arg1 = 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (aiVector3D *)new aiVector3D((aiVector3D const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___addnset__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiVector3D *arg2 = 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (aiVector3D *) &(arg1)->operator +=((aiVector3D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___subnset__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiVector3D *arg2 = 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (aiVector3D *) &(arg1)->operator -=((aiVector3D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_0(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float arg2 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVector3D *) &(arg1)->operator *=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___divnset__(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float arg2 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVector3D *) &(arg1)->operator /=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiMatrix3x3 *arg2 = 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiMatrix3x3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 const & type is null", 0);
    return 0;
  } 
  result = (aiVector3D *) &(arg1)->operator *=((aiMatrix3x3 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiMatrix4x4 *arg2 = 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 const & type is null", 0);
    return 0;
  } 
  result = (aiVector3D *) &(arg1)->operator *=((aiMatrix4x4 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D___idx____SWIG_0(void * jarg1, unsigned int jarg2) {
  float jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  unsigned int arg2 ;
  float result;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (float)((aiVector3D const *)arg1)->operator [](arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3D___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiVector3D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVector3D const *)arg1)->operator ==((aiVector3D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3D___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiVector3D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVector3D const *)arg1)->operator !=((aiVector3D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_Set(void * jarg1, float jarg2, float jarg3, float jarg4) {
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 = (float) 0. ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  (arg1)->Set(arg2,arg3,arg4);
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_SquareLength(void * jarg1) {
  float jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float result;
  
  arg1 = (aiVector3D *)jarg1; 
  result = (float)((aiVector3D const *)arg1)->SquareLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_Length(void * jarg1) {
  float jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float result;
  
  arg1 = (aiVector3D *)jarg1; 
  result = (float)((aiVector3D const *)arg1)->Length();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D_Normalize(void * jarg1) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  result = (aiVector3D *) &(arg1)->Normalize();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D_SymMul(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  aiVector3D *arg2 = 0 ;
  aiVector3D result;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (arg1)->SymMul((aiVector3D const &)*arg2);
  jresult = new aiVector3D((const aiVector3D &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_x_set(void * jarg1, float jarg2) {
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float arg2 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_x_get(void * jarg1) {
  float jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float result;
  
  arg1 = (aiVector3D *)jarg1; 
  result = (float) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_y_set(void * jarg1, float jarg2) {
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float arg2 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_y_get(void * jarg1) {
  float jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float result;
  
  arg1 = (aiVector3D *)jarg1; 
  result = (float) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_z_set(void * jarg1, float jarg2) {
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float arg2 ;
  
  arg1 = (aiVector3D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_z_get(void * jarg1) {
  float jresult ;
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  float result;
  
  arg1 = (aiVector3D *)jarg1; 
  result = (float) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector3D(void * jarg1) {
  aiVector3D *arg1 = (aiVector3D *) 0 ;
  
  arg1 = (aiVector3D *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_0() {
  void * jresult ;
  aiColor4D *result = 0 ;
  
  result = (aiColor4D *)new aiColor4D();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  aiColor4D *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  result = (aiColor4D *)new aiColor4D(arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_2(float jarg1) {
  void * jresult ;
  float arg1 ;
  aiColor4D *result = 0 ;
  
  arg1 = (float)jarg1; 
  result = (aiColor4D *)new aiColor4D(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_3(void * jarg1) {
  void * jresult ;
  aiColor4D *arg1 = 0 ;
  aiColor4D *result = 0 ;
  
  arg1 = (aiColor4D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0);
    return 0;
  } 
  result = (aiColor4D *)new aiColor4D((aiColor4D const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___addnset__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  aiColor4D *arg2 = 0 ;
  aiColor4D *result = 0 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (aiColor4D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0);
    return 0;
  } 
  result = (aiColor4D *) &(arg1)->operator +=((aiColor4D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___subnset__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  aiColor4D *arg2 = 0 ;
  aiColor4D *result = 0 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (aiColor4D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0);
    return 0;
  } 
  result = (aiColor4D *) &(arg1)->operator -=((aiColor4D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___mulnset__(void * jarg1, float jarg2) {
  void * jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float arg2 ;
  aiColor4D *result = 0 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiColor4D *) &(arg1)->operator *=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___divnset__(void * jarg1, float jarg2) {
  void * jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float arg2 ;
  aiColor4D *result = 0 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiColor4D *) &(arg1)->operator /=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  aiColor4D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (aiColor4D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiColor4D const *)arg1)->operator ==((aiColor4D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  aiColor4D *arg2 = 0 ;
  bool result;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (aiColor4D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiColor4D const *)arg1)->operator !=((aiColor4D const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D___idx____SWIG_0(void * jarg1, unsigned int jarg2) {
  float jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  unsigned int arg2 ;
  float result;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (float)((aiColor4D const *)arg1)->operator [](arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D_IsBlack(void * jarg1) {
  unsigned int jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  bool result;
  
  arg1 = (aiColor4D *)jarg1; 
  result = (bool)((aiColor4D const *)arg1)->IsBlack();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_r_set(void * jarg1, float jarg2) {
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->r = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_r_get(void * jarg1) {
  float jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float result;
  
  arg1 = (aiColor4D *)jarg1; 
  result = (float) ((arg1)->r);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_g_set(void * jarg1, float jarg2) {
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->g = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_g_get(void * jarg1) {
  float jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float result;
  
  arg1 = (aiColor4D *)jarg1; 
  result = (float) ((arg1)->g);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_b_set(void * jarg1, float jarg2) {
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_b_get(void * jarg1) {
  float jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float result;
  
  arg1 = (aiColor4D *)jarg1; 
  result = (float) ((arg1)->b);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_a_set(void * jarg1, float jarg2) {
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float arg2 ;
  
  arg1 = (aiColor4D *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_a_get(void * jarg1) {
  float jresult ;
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  float result;
  
  arg1 = (aiColor4D *)jarg1; 
  result = (float) ((arg1)->a);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiColor4D(void * jarg1) {
  aiColor4D *arg1 = (aiColor4D *) 0 ;
  
  arg1 = (aiColor4D *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_0() {
  void * jresult ;
  aiMatrix3x3 *result = 0 ;
  
  result = (aiMatrix3x3 *)new aiMatrix3x3();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  float arg8 ;
  float arg9 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  arg5 = (float)jarg5; 
  arg6 = (float)jarg6; 
  arg7 = (float)jarg7; 
  arg8 = (float)jarg8; 
  arg9 = (float)jarg9; 
  result = (aiMatrix3x3 *)new aiMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_2(void * jarg1) {
  void * jresult ;
  aiMatrix4x4 *arg1 = 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 const & type is null", 0);
    return 0;
  } 
  result = (aiMatrix3x3 *)new aiMatrix3x3((aiMatrix4x4 const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Transpose(void * jarg1) {
  void * jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (aiMatrix3x3 *) &(arg1)->Transpose();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Inverse(void * jarg1) {
  void * jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (aiMatrix3x3 *) &(arg1)->Inverse();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_Determinant(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float)((aiMatrix3x3 const *)arg1)->Determinant();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_RotationZ(float jarg1, void * jarg2) {
  void * jresult ;
  float arg1 ;
  aiMatrix3x3 *arg2 = 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (aiMatrix3x3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix3x3 *) &aiMatrix3x3::RotationZ(arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Rotation(float jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  float arg1 ;
  aiVector3D *arg2 = 0 ;
  aiMatrix3x3 *arg3 = 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg3 = (aiMatrix3x3 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix3x3 *) &aiMatrix3x3::Rotation(arg1,(aiVector3D const &)*arg2,*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Translation(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector2D *arg1 = 0 ;
  aiMatrix3x3 *arg2 = 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (aiVector2D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiMatrix3x3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix3x3 *) &aiMatrix3x3::Translation((aiVector2D const &)*arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_FromToMatrix(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  aiVector3D *arg1 = 0 ;
  aiVector3D *arg2 = 0 ;
  aiMatrix3x3 *arg3 = 0 ;
  aiMatrix3x3 *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg3 = (aiMatrix3x3 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix3x3 *) &aiMatrix3x3::FromToMatrix((aiVector3D const &)*arg1,(aiVector3D const &)*arg2,*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a1_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a1_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->a1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a2_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a2_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->a2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a3_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a3_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->a3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b1_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b1_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->b1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b2_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b2_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->b2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b3_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b3_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->b3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c1_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c1_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->c1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c2_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c2_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->c2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c3_set(void * jarg1, float jarg2) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c3_get(void * jarg1) {
  float jresult ;
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  float result;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  result = (float) ((arg1)->c3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMatrix3x3(void * jarg1) {
  aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ;
  
  arg1 = (aiMatrix3x3 *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_0() {
  void * jresult ;
  aiMatrix4x4 *result = 0 ;
  
  result = (aiMatrix4x4 *)new aiMatrix4x4();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9, float jarg10, float jarg11, float jarg12, float jarg13, float jarg14, float jarg15, float jarg16) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  float arg8 ;
  float arg9 ;
  float arg10 ;
  float arg11 ;
  float arg12 ;
  float arg13 ;
  float arg14 ;
  float arg15 ;
  float arg16 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  arg5 = (float)jarg5; 
  arg6 = (float)jarg6; 
  arg7 = (float)jarg7; 
  arg8 = (float)jarg8; 
  arg9 = (float)jarg9; 
  arg10 = (float)jarg10; 
  arg11 = (float)jarg11; 
  arg12 = (float)jarg12; 
  arg13 = (float)jarg13; 
  arg14 = (float)jarg14; 
  arg15 = (float)jarg15; 
  arg16 = (float)jarg16; 
  result = (aiMatrix4x4 *)new aiMatrix4x4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_2(void * jarg1) {
  void * jresult ;
  aiMatrix3x3 *arg1 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiMatrix3x3 *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 const & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *)new aiMatrix4x4((aiMatrix3x3 const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Transpose(void * jarg1) {
  void * jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (aiMatrix4x4 *) &(arg1)->Transpose();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Inverse(void * jarg1) {
  void * jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (aiMatrix4x4 *) &(arg1)->Inverse();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_Determinant(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float)((aiMatrix4x4 const *)arg1)->Determinant();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix4x4_IsIdentity(void * jarg1) {
  unsigned int jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  bool result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (bool)((aiMatrix4x4 const *)arg1)->IsIdentity();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_Decompose(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  aiVector3D *arg2 = 0 ;
  aiQuaternion *arg3 = 0 ;
  aiVector3D *arg4 = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D & type is null", 0);
    return ;
  } 
  arg3 = (aiQuaternion *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion & type is null", 0);
    return ;
  } 
  arg4 = (aiVector3D *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D & type is null", 0);
    return ;
  } 
  ((aiMatrix4x4 const *)arg1)->Decompose(*arg2,*arg3,*arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_DecomposeNoScaling(void * jarg1, void * jarg2, void * jarg3) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  aiQuaternion *arg2 = 0 ;
  aiVector3D *arg3 = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (aiQuaternion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion & type is null", 0);
    return ;
  } 
  arg3 = (aiVector3D *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D & type is null", 0);
    return ;
  } 
  ((aiMatrix4x4 const *)arg1)->DecomposeNoScaling(*arg2,*arg3);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
  void * jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  result = (aiMatrix4x4 *) &(arg1)->FromEulerAnglesXYZ(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  aiVector3D *arg2 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &(arg1)->FromEulerAnglesXYZ((aiVector3D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationX(float jarg1, void * jarg2) {
  void * jresult ;
  float arg1 ;
  aiMatrix4x4 *arg2 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::RotationX(arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationY(float jarg1, void * jarg2) {
  void * jresult ;
  float arg1 ;
  aiMatrix4x4 *arg2 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::RotationY(arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationZ(float jarg1, void * jarg2) {
  void * jresult ;
  float arg1 ;
  aiMatrix4x4 *arg2 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::RotationZ(arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Rotation(float jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  float arg1 ;
  aiVector3D *arg2 = 0 ;
  aiMatrix4x4 *arg3 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg3 = (aiMatrix4x4 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::Rotation(arg1,(aiVector3D const &)*arg2,*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Translation(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = 0 ;
  aiMatrix4x4 *arg2 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::Translation((aiVector3D const &)*arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Scaling(void * jarg1, void * jarg2) {
  void * jresult ;
  aiVector3D *arg1 = 0 ;
  aiMatrix4x4 *arg2 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::Scaling((aiVector3D const &)*arg1,*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromToMatrix(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  aiVector3D *arg1 = 0 ;
  aiVector3D *arg2 = 0 ;
  aiMatrix4x4 *arg3 = 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiVector3D *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  arg3 = (aiMatrix4x4 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return 0;
  } 
  result = (aiMatrix4x4 *) &aiMatrix4x4::FromToMatrix((aiVector3D const &)*arg1,(aiVector3D const &)*arg2,*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a1_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a1_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->a1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a2_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a2_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->a2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a3_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a3_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->a3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a4_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->a4 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a4_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->a4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b1_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b1_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->b1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b2_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b2_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->b2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b3_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b3_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->b3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b4_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->b4 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b4_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->b4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c1_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c1_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->c1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c2_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c2_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->c2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c3_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c3_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->c3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c4_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->c4 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c4_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->c4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d1_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->d1 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d1_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->d1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d2_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->d2 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d2_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->d2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d3_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->d3 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d3_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->d3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d4_set(void * jarg1, float jarg2) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float arg2 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->d4 = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d4_get(void * jarg1) {
  float jresult ;
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  float result;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  result = (float) ((arg1)->d4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMatrix4x4(void * jarg1) {
  aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ;
  
  arg1 = (aiMatrix4x4 *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mName_set(void * jarg1, void * jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCamera_mName_get(void * jarg1) {
  void * jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mPosition_set(void * jarg1, void * jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mPosition = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCamera_mPosition_get(void * jarg1) {
  void * jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  result = (aiVector3D *)& ((arg1)->mPosition);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mUp_set(void * jarg1, void * jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mUp = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCamera_mUp_get(void * jarg1) {
  void * jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  result = (aiVector3D *)& ((arg1)->mUp);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mLookAt_set(void * jarg1, void * jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mLookAt = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCamera_mLookAt_get(void * jarg1) {
  void * jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  result = (aiVector3D *)& ((arg1)->mLookAt);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mHorizontalFOV_set(void * jarg1, float jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  float arg2 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mHorizontalFOV = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiCamera_mHorizontalFOV_get(void * jarg1) {
  float jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  float result;
  
  arg1 = (aiCamera *)jarg1; 
  result = (float) ((arg1)->mHorizontalFOV);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mClipPlaneNear_set(void * jarg1, float jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  float arg2 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mClipPlaneNear = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiCamera_mClipPlaneNear_get(void * jarg1) {
  float jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  float result;
  
  arg1 = (aiCamera *)jarg1; 
  result = (float) ((arg1)->mClipPlaneNear);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mClipPlaneFar_set(void * jarg1, float jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  float arg2 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mClipPlaneFar = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiCamera_mClipPlaneFar_get(void * jarg1) {
  float jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  float result;
  
  arg1 = (aiCamera *)jarg1; 
  result = (float) ((arg1)->mClipPlaneFar);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mAspect_set(void * jarg1, float jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  float arg2 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mAspect = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiCamera_mAspect_get(void * jarg1) {
  float jresult ;
  aiCamera *arg1 = (aiCamera *) 0 ;
  float result;
  
  arg1 = (aiCamera *)jarg1; 
  result = (float) ((arg1)->mAspect);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiCamera() {
  void * jresult ;
  aiCamera *result = 0 ;
  
  result = (aiCamera *)new aiCamera();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_GetCameraMatrix(void * jarg1, void * jarg2) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  aiMatrix4x4 *arg2 = 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0);
    return ;
  } 
  ((aiCamera const *)arg1)->GetCameraMatrix(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiCamera(void * jarg1) {
  aiCamera *arg1 = (aiCamera *) 0 ;
  
  arg1 = (aiCamera *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mName_set(void * jarg1, void * jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLight_mName_get(void * jarg1) {
  void * jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mType_set(void * jarg1, int jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiLightSourceType arg2 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiLightSourceType)jarg2; 
  if (arg1) (arg1)->mType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiLight_mType_get(void * jarg1) {
  int jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiLightSourceType result;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiLightSourceType) ((arg1)->mType);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mPosition_set(void * jarg1, void * jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mPosition = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLight_mPosition_get(void * jarg1) {
  void * jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiVector3D *)& ((arg1)->mPosition);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mDirection_set(void * jarg1, void * jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mDirection = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLight_mDirection_get(void * jarg1) {
  void * jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiVector3D *)& ((arg1)->mDirection);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mAttenuationConstant_set(void * jarg1, float jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  float arg2 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mAttenuationConstant = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiLight_mAttenuationConstant_get(void * jarg1) {
  float jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  float result;
  
  arg1 = (aiLight *)jarg1; 
  result = (float) ((arg1)->mAttenuationConstant);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mAttenuationLinear_set(void * jarg1, float jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  float arg2 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mAttenuationLinear = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiLight_mAttenuationLinear_get(void * jarg1) {
  float jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  float result;
  
  arg1 = (aiLight *)jarg1; 
  result = (float) ((arg1)->mAttenuationLinear);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mAttenuationQuadratic_set(void * jarg1, float jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  float arg2 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mAttenuationQuadratic = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiLight_mAttenuationQuadratic_get(void * jarg1) {
  float jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  float result;
  
  arg1 = (aiLight *)jarg1; 
  result = (float) ((arg1)->mAttenuationQuadratic);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mColorDiffuse_set(void * jarg1, void * jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiColor3D *arg2 = (aiColor3D *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiColor3D *)jarg2; 
  if (arg1) (arg1)->mColorDiffuse = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLight_mColorDiffuse_get(void * jarg1) {
  void * jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiColor3D *result = 0 ;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiColor3D *)& ((arg1)->mColorDiffuse);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mColorSpecular_set(void * jarg1, void * jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiColor3D *arg2 = (aiColor3D *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiColor3D *)jarg2; 
  if (arg1) (arg1)->mColorSpecular = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLight_mColorSpecular_get(void * jarg1) {
  void * jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiColor3D *result = 0 ;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiColor3D *)& ((arg1)->mColorSpecular);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mColorAmbient_set(void * jarg1, void * jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  aiColor3D *arg2 = (aiColor3D *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (aiColor3D *)jarg2; 
  if (arg1) (arg1)->mColorAmbient = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLight_mColorAmbient_get(void * jarg1) {
  void * jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  aiColor3D *result = 0 ;
  
  arg1 = (aiLight *)jarg1; 
  result = (aiColor3D *)& ((arg1)->mColorAmbient);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mAngleInnerCone_set(void * jarg1, float jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  float arg2 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mAngleInnerCone = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiLight_mAngleInnerCone_get(void * jarg1) {
  float jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  float result;
  
  arg1 = (aiLight *)jarg1; 
  result = (float) ((arg1)->mAngleInnerCone);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLight_mAngleOuterCone_set(void * jarg1, float jarg2) {
  aiLight *arg1 = (aiLight *) 0 ;
  float arg2 ;
  
  arg1 = (aiLight *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mAngleOuterCone = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiLight_mAngleOuterCone_get(void * jarg1) {
  float jresult ;
  aiLight *arg1 = (aiLight *) 0 ;
  float result;
  
  arg1 = (aiLight *)jarg1; 
  result = (float) ((arg1)->mAngleOuterCone);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiLight() {
  void * jresult ;
  aiLight *result = 0 ;
  
  result = (aiLight *)new aiLight();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiLight(void * jarg1) {
  aiLight *arg1 = (aiLight *) 0 ;
  
  arg1 = (aiLight *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKey_mTime_set(void * jarg1, double jarg2) {
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  double arg2 ;
  
  arg1 = (aiVectorKey *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->mTime = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_aiVectorKey_mTime_get(void * jarg1) {
  double jresult ;
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  double result;
  
  arg1 = (aiVectorKey *)jarg1; 
  result = (double) ((arg1)->mTime);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKey_mValue_set(void * jarg1, void * jarg2) {
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiVectorKey *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mValue = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVectorKey_mValue_get(void * jarg1) {
  void * jresult ;
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiVectorKey *)jarg1; 
  result = (aiVector3D *)& ((arg1)->mValue);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVectorKey__SWIG_0() {
  void * jresult ;
  aiVectorKey *result = 0 ;
  
  result = (aiVectorKey *)new aiVectorKey();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVectorKey__SWIG_1(double jarg1, void * jarg2) {
  void * jresult ;
  double arg1 ;
  aiVector3D *arg2 = 0 ;
  aiVectorKey *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (aiVectorKey *)new aiVectorKey(arg1,(aiVector3D const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVectorKey___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  aiVectorKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVectorKey *)jarg1; 
  arg2 = (aiVectorKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVectorKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVectorKey const *)arg1)->operator ==((aiVectorKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVectorKey___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  aiVectorKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVectorKey *)jarg1; 
  arg2 = (aiVectorKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVectorKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVectorKey const *)arg1)->operator !=((aiVectorKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVectorKey___smaller__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  aiVectorKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVectorKey *)jarg1; 
  arg2 = (aiVectorKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVectorKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVectorKey const *)arg1)->operator <((aiVectorKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVectorKey___greater__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  aiVectorKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiVectorKey *)jarg1; 
  arg2 = (aiVectorKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVectorKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiVectorKey const *)arg1)->operator >((aiVectorKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVectorKey(void * jarg1) {
  aiVectorKey *arg1 = (aiVectorKey *) 0 ;
  
  arg1 = (aiVectorKey *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKey_mTime_set(void * jarg1, double jarg2) {
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  double arg2 ;
  
  arg1 = (aiQuatKey *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->mTime = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_aiQuatKey_mTime_get(void * jarg1) {
  double jresult ;
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  double result;
  
  arg1 = (aiQuatKey *)jarg1; 
  result = (double) ((arg1)->mTime);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKey_mValue_set(void * jarg1, void * jarg2) {
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  aiQuaternion *arg2 = (aiQuaternion *) 0 ;
  
  arg1 = (aiQuatKey *)jarg1; 
  arg2 = (aiQuaternion *)jarg2; 
  if (arg1) (arg1)->mValue = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuatKey_mValue_get(void * jarg1) {
  void * jresult ;
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  aiQuaternion *result = 0 ;
  
  arg1 = (aiQuatKey *)jarg1; 
  result = (aiQuaternion *)& ((arg1)->mValue);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuatKey__SWIG_0() {
  void * jresult ;
  aiQuatKey *result = 0 ;
  
  result = (aiQuatKey *)new aiQuatKey();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuatKey__SWIG_1(double jarg1, void * jarg2) {
  void * jresult ;
  double arg1 ;
  aiQuaternion *arg2 = 0 ;
  aiQuatKey *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (aiQuaternion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0);
    return 0;
  } 
  result = (aiQuatKey *)new aiQuatKey(arg1,(aiQuaternion const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuatKey___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  aiQuatKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiQuatKey *)jarg1; 
  arg2 = (aiQuatKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuatKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiQuatKey const *)arg1)->operator ==((aiQuatKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuatKey___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  aiQuatKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiQuatKey *)jarg1; 
  arg2 = (aiQuatKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuatKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiQuatKey const *)arg1)->operator !=((aiQuatKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuatKey___smaller__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  aiQuatKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiQuatKey *)jarg1; 
  arg2 = (aiQuatKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuatKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiQuatKey const *)arg1)->operator <((aiQuatKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuatKey___greater__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  aiQuatKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiQuatKey *)jarg1; 
  arg2 = (aiQuatKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuatKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiQuatKey const *)arg1)->operator >((aiQuatKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiQuatKey(void * jarg1) {
  aiQuatKey *arg1 = (aiQuatKey *) 0 ;
  
  arg1 = (aiQuatKey *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKey_mTime_set(void * jarg1, double jarg2) {
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  double arg2 ;
  
  arg1 = (aiMeshKey *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->mTime = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_aiMeshKey_mTime_get(void * jarg1) {
  double jresult ;
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  double result;
  
  arg1 = (aiMeshKey *)jarg1; 
  result = (double) ((arg1)->mTime);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKey_mValue_set(void * jarg1, unsigned int jarg2) {
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMeshKey *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mValue = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKey_mValue_get(void * jarg1) {
  unsigned int jresult ;
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  unsigned int result;
  
  arg1 = (aiMeshKey *)jarg1; 
  result = (unsigned int) ((arg1)->mValue);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshKey__SWIG_0() {
  void * jresult ;
  aiMeshKey *result = 0 ;
  
  result = (aiMeshKey *)new aiMeshKey();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshKey__SWIG_1(double jarg1, unsigned int jarg2) {
  void * jresult ;
  double arg1 ;
  unsigned int arg2 ;
  aiMeshKey *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (aiMeshKey *)new aiMeshKey(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKey___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  aiMeshKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiMeshKey *)jarg1; 
  arg2 = (aiMeshKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMeshKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiMeshKey const *)arg1)->operator ==((aiMeshKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKey___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  aiMeshKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiMeshKey *)jarg1; 
  arg2 = (aiMeshKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMeshKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiMeshKey const *)arg1)->operator !=((aiMeshKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKey___smaller__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  aiMeshKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiMeshKey *)jarg1; 
  arg2 = (aiMeshKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMeshKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiMeshKey const *)arg1)->operator <((aiMeshKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKey___greater__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  aiMeshKey *arg2 = 0 ;
  bool result;
  
  arg1 = (aiMeshKey *)jarg1; 
  arg2 = (aiMeshKey *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMeshKey const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiMeshKey const *)arg1)->operator >((aiMeshKey const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMeshKey(void * jarg1) {
  aiMeshKey *arg1 = (aiMeshKey *) 0 ;
  
  arg1 = (aiMeshKey *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnim_mNodeName_set(void * jarg1, void * jarg2) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mNodeName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnim_mNodeName_get(void * jarg1) {
  void * jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (aiString *)& ((arg1)->mNodeName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnim_mNumPositionKeys_set(void * jarg1, unsigned int jarg2) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumPositionKeys = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeAnim_mNumPositionKeys_get(void * jarg1) {
  unsigned int jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  unsigned int result;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (unsigned int) ((arg1)->mNumPositionKeys);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnim_mNumRotationKeys_set(void * jarg1, unsigned int jarg2) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumRotationKeys = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeAnim_mNumRotationKeys_get(void * jarg1) {
  unsigned int jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  unsigned int result;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (unsigned int) ((arg1)->mNumRotationKeys);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnim_mNumScalingKeys_set(void * jarg1, unsigned int jarg2) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumScalingKeys = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeAnim_mNumScalingKeys_get(void * jarg1) {
  unsigned int jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  unsigned int result;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (unsigned int) ((arg1)->mNumScalingKeys);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnim_mPreState_set(void * jarg1, int jarg2) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  aiAnimBehaviour arg2 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  arg2 = (aiAnimBehaviour)jarg2; 
  if (arg1) (arg1)->mPreState = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiNodeAnim_mPreState_get(void * jarg1) {
  int jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  aiAnimBehaviour result;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (aiAnimBehaviour) ((arg1)->mPreState);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnim_mPostState_set(void * jarg1, int jarg2) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  aiAnimBehaviour arg2 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  arg2 = (aiAnimBehaviour)jarg2; 
  if (arg1) (arg1)->mPostState = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiNodeAnim_mPostState_get(void * jarg1) {
  int jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  aiAnimBehaviour result;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (aiAnimBehaviour) ((arg1)->mPostState);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeAnim() {
  void * jresult ;
  aiNodeAnim *result = 0 ;
  
  result = (aiNodeAnim *)new aiNodeAnim();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiNodeAnim(void * jarg1) {
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnim_GetmPositionKeys(void * jarg1) {
  void * jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (std::vector< aiVectorKey * > *)aiNodeAnim_GetmPositionKeys(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnim_GetmRotationKeys(void * jarg1) {
  void * jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  std::vector< aiQuatKey * > *result = 0 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (std::vector< aiQuatKey * > *)aiNodeAnim_GetmRotationKeys(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnim_GetmScalingKeys(void * jarg1) {
  void * jresult ;
  aiNodeAnim *arg1 = (aiNodeAnim *) 0 ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  arg1 = (aiNodeAnim *)jarg1; 
  result = (std::vector< aiVectorKey * > *)aiNodeAnim_GetmScalingKeys(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnim_mName_set(void * jarg1, void * jarg2) {
  aiMeshAnim *arg1 = (aiMeshAnim *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiMeshAnim *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshAnim_mName_get(void * jarg1) {
  void * jresult ;
  aiMeshAnim *arg1 = (aiMeshAnim *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiMeshAnim *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnim_mNumKeys_set(void * jarg1, unsigned int jarg2) {
  aiMeshAnim *arg1 = (aiMeshAnim *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMeshAnim *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumKeys = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshAnim_mNumKeys_get(void * jarg1) {
  unsigned int jresult ;
  aiMeshAnim *arg1 = (aiMeshAnim *) 0 ;
  unsigned int result;
  
  arg1 = (aiMeshAnim *)jarg1; 
  result = (unsigned int) ((arg1)->mNumKeys);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshAnim() {
  void * jresult ;
  aiMeshAnim *result = 0 ;
  
  result = (aiMeshAnim *)new aiMeshAnim();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMeshAnim(void * jarg1) {
  aiMeshAnim *arg1 = (aiMeshAnim *) 0 ;
  
  arg1 = (aiMeshAnim *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshAnim_GetmKeys(void * jarg1) {
  void * jresult ;
  aiMeshAnim *arg1 = (aiMeshAnim *) 0 ;
  std::vector< aiMeshKey * > *result = 0 ;
  
  arg1 = (aiMeshAnim *)jarg1; 
  result = (std::vector< aiMeshKey * > *)aiMeshAnim_GetmKeys(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimation_mName_set(void * jarg1, void * jarg2) {
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiAnimation *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimation_mName_get(void * jarg1) {
  void * jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimation_mDuration_set(void * jarg1, double jarg2) {
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  double arg2 ;
  
  arg1 = (aiAnimation *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->mDuration = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_aiAnimation_mDuration_get(void * jarg1) {
  double jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  double result;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (double) ((arg1)->mDuration);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimation_mTicksPerSecond_set(void * jarg1, double jarg2) {
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  double arg2 ;
  
  arg1 = (aiAnimation *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->mTicksPerSecond = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_aiAnimation_mTicksPerSecond_get(void * jarg1) {
  double jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  double result;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (double) ((arg1)->mTicksPerSecond);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimation_mNumChannels_set(void * jarg1, unsigned int jarg2) {
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiAnimation *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumChannels = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimation_mNumChannels_get(void * jarg1) {
  unsigned int jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  unsigned int result;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (unsigned int) ((arg1)->mNumChannels);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimation_mNumMeshChannels_set(void * jarg1, unsigned int jarg2) {
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiAnimation *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumMeshChannels = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimation_mNumMeshChannels_get(void * jarg1) {
  unsigned int jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  unsigned int result;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (unsigned int) ((arg1)->mNumMeshChannels);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimation() {
  void * jresult ;
  aiAnimation *result = 0 ;
  
  result = (aiAnimation *)new aiAnimation();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiAnimation(void * jarg1) {
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  
  arg1 = (aiAnimation *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimation_GetmChannels(void * jarg1) {
  void * jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  std::vector< aiNodeAnim * > *result = 0 ;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (std::vector< aiNodeAnim * > *)aiAnimation_GetmChannels(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimation_GetmMeshChannels(void * jarg1) {
  void * jresult ;
  aiAnimation *arg1 = (aiAnimation *) 0 ;
  std::vector< aiMeshAnim * > *result = 0 ;
  
  arg1 = (aiAnimation *)jarg1; 
  result = (std::vector< aiMeshAnim * > *)aiAnimation_GetmMeshChannels(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_FACE_INDICES_get() {
  int jresult ;
  int result;
  
  result = (int)(0x7fff);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_BONE_WEIGHTS_get() {
  int jresult ;
  int result;
  
  result = (int)(0x7fffffff);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_VERTICES_get() {
  int jresult ;
  int result;
  
  result = (int)(0x7fffffff);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_FACES_get() {
  int jresult ;
  int result;
  
  result = (int)(0x7fffffff);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_NUMBER_OF_COLOR_SETS_get() {
  int jresult ;
  int result;
  
  result = (int)(0x4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_NUMBER_OF_TEXTURECOORDS_get() {
  int jresult ;
  int result;
  
  result = (int)(0x4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFace_mNumIndices_set(void * jarg1, unsigned int jarg2) {
  aiFace *arg1 = (aiFace *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiFace *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumIndices = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiFace_mNumIndices_get(void * jarg1) {
  unsigned int jresult ;
  aiFace *arg1 = (aiFace *) 0 ;
  unsigned int result;
  
  arg1 = (aiFace *)jarg1; 
  result = (unsigned int) ((arg1)->mNumIndices);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiFace__SWIG_0() {
  void * jresult ;
  aiFace *result = 0 ;
  
  result = (aiFace *)new aiFace();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiFace(void * jarg1) {
  aiFace *arg1 = (aiFace *) 0 ;
  
  arg1 = (aiFace *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiFace__SWIG_1(void * jarg1) {
  void * jresult ;
  aiFace *arg1 = 0 ;
  aiFace *result = 0 ;
  
  arg1 = (aiFace *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiFace const & type is null", 0);
    return 0;
  } 
  result = (aiFace *)new aiFace((aiFace const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiFace___set__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiFace *arg1 = (aiFace *) 0 ;
  aiFace *arg2 = 0 ;
  aiFace *result = 0 ;
  
  arg1 = (aiFace *)jarg1; 
  arg2 = (aiFace *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiFace const & type is null", 0);
    return 0;
  } 
  result = (aiFace *) &(arg1)->operator =((aiFace const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiFace___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiFace *arg1 = (aiFace *) 0 ;
  aiFace *arg2 = 0 ;
  bool result;
  
  arg1 = (aiFace *)jarg1; 
  arg2 = (aiFace *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiFace const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiFace const *)arg1)->operator ==((aiFace const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiFace___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiFace *arg1 = (aiFace *) 0 ;
  aiFace *arg2 = 0 ;
  bool result;
  
  arg1 = (aiFace *)jarg1; 
  arg2 = (aiFace *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiFace const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiFace const *)arg1)->operator !=((aiFace const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiFace_GetmIndices(void * jarg1) {
  void * jresult ;
  aiFace *arg1 = (aiFace *) 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (aiFace *)jarg1; 
  result = (std::vector< unsigned int > *)aiFace_GetmIndices(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeight_mVertexId_set(void * jarg1, unsigned int jarg2) {
  aiVertexWeight *arg1 = (aiVertexWeight *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiVertexWeight *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mVertexId = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVertexWeight_mVertexId_get(void * jarg1) {
  unsigned int jresult ;
  aiVertexWeight *arg1 = (aiVertexWeight *) 0 ;
  unsigned int result;
  
  arg1 = (aiVertexWeight *)jarg1; 
  result = (unsigned int) ((arg1)->mVertexId);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeight_mWeight_set(void * jarg1, float jarg2) {
  aiVertexWeight *arg1 = (aiVertexWeight *) 0 ;
  float arg2 ;
  
  arg1 = (aiVertexWeight *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mWeight = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiVertexWeight_mWeight_get(void * jarg1) {
  float jresult ;
  aiVertexWeight *arg1 = (aiVertexWeight *) 0 ;
  float result;
  
  arg1 = (aiVertexWeight *)jarg1; 
  result = (float) ((arg1)->mWeight);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVertexWeight__SWIG_0() {
  void * jresult ;
  aiVertexWeight *result = 0 ;
  
  result = (aiVertexWeight *)new aiVertexWeight();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVertexWeight__SWIG_1(unsigned int jarg1, float jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  float arg2 ;
  aiVertexWeight *result = 0 ;
  
  arg1 = (unsigned int)jarg1; 
  arg2 = (float)jarg2; 
  result = (aiVertexWeight *)new aiVertexWeight(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVertexWeight(void * jarg1) {
  aiVertexWeight *arg1 = (aiVertexWeight *) 0 ;
  
  arg1 = (aiVertexWeight *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBone_mName_set(void * jarg1, void * jarg2) {
  aiBone *arg1 = (aiBone *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiBone *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBone_mName_get(void * jarg1) {
  void * jresult ;
  aiBone *arg1 = (aiBone *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiBone *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBone_mNumWeights_set(void * jarg1, unsigned int jarg2) {
  aiBone *arg1 = (aiBone *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiBone *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumWeights = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiBone_mNumWeights_get(void * jarg1) {
  unsigned int jresult ;
  aiBone *arg1 = (aiBone *) 0 ;
  unsigned int result;
  
  arg1 = (aiBone *)jarg1; 
  result = (unsigned int) ((arg1)->mNumWeights);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBone_mOffsetMatrix_set(void * jarg1, void * jarg2) {
  aiBone *arg1 = (aiBone *) 0 ;
  aiMatrix4x4 *arg2 = (aiMatrix4x4 *) 0 ;
  
  arg1 = (aiBone *)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2; 
  if (arg1) (arg1)->mOffsetMatrix = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBone_mOffsetMatrix_get(void * jarg1) {
  void * jresult ;
  aiBone *arg1 = (aiBone *) 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiBone *)jarg1; 
  result = (aiMatrix4x4 *)& ((arg1)->mOffsetMatrix);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiBone__SWIG_0() {
  void * jresult ;
  aiBone *result = 0 ;
  
  result = (aiBone *)new aiBone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiBone__SWIG_1(void * jarg1) {
  void * jresult ;
  aiBone *arg1 = 0 ;
  aiBone *result = 0 ;
  
  arg1 = (aiBone *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiBone const & type is null", 0);
    return 0;
  } 
  result = (aiBone *)new aiBone((aiBone const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiBone(void * jarg1) {
  aiBone *arg1 = (aiBone *) 0 ;
  
  arg1 = (aiBone *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBone_GetmWeights(void * jarg1) {
  void * jresult ;
  aiBone *arg1 = (aiBone *) 0 ;
  std::vector< aiVertexWeight * > *result = 0 ;
  
  arg1 = (aiBone *)jarg1; 
  result = (std::vector< aiVertexWeight * > *)aiBone_GetmWeights(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMesh_mBitangents_set(void * jarg1, void * jarg2) {
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  aiVector3D *arg2 = (aiVector3D *) 0 ;
  
  arg1 = (aiAnimMesh *)jarg1; 
  arg2 = (aiVector3D *)jarg2; 
  if (arg1) (arg1)->mBitangents = arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimMesh_mBitangents_get(void * jarg1) {
  void * jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  aiVector3D *result = 0 ;
  
  arg1 = (aiAnimMesh *)jarg1; 
  result = (aiVector3D *) ((arg1)->mBitangents);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMesh_mNumVertices_set(void * jarg1, unsigned int jarg2) {
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiAnimMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumVertices = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMesh_mNumVertices_get(void * jarg1) {
  unsigned int jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiAnimMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mNumVertices);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimMesh() {
  void * jresult ;
  aiAnimMesh *result = 0 ;
  
  result = (aiAnimMesh *)new aiAnimMesh();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiAnimMesh(void * jarg1) {
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  
  arg1 = (aiAnimMesh *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMesh_HasPositions(void * jarg1) {
  unsigned int jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  bool result;
  
  arg1 = (aiAnimMesh *)jarg1; 
  result = (bool)((aiAnimMesh const *)arg1)->HasPositions();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMesh_HasNormals(void * jarg1) {
  unsigned int jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  bool result;
  
  arg1 = (aiAnimMesh *)jarg1; 
  result = (bool)((aiAnimMesh const *)arg1)->HasNormals();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMesh_HasTangentsAndBitangents(void * jarg1) {
  unsigned int jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  bool result;
  
  arg1 = (aiAnimMesh *)jarg1; 
  result = (bool)((aiAnimMesh const *)arg1)->HasTangentsAndBitangents();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMesh_HasVertexColors(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (aiAnimMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)((aiAnimMesh const *)arg1)->HasVertexColors(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMesh_HasTextureCoords(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  aiAnimMesh *arg1 = (aiAnimMesh *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (aiAnimMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)((aiAnimMesh const *)arg1)->HasTextureCoords(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mPrimitiveTypes_set(void * jarg1, unsigned int jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mPrimitiveTypes = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_mPrimitiveTypes_get(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mPrimitiveTypes);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mNumVertices_set(void * jarg1, unsigned int jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumVertices = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_mNumVertices_get(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mNumVertices);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mNumFaces_set(void * jarg1, unsigned int jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumFaces = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_mNumFaces_get(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mNumFaces);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mNumBones_set(void * jarg1, unsigned int jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumBones = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_mNumBones_get(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mNumBones);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mMaterialIndex_set(void * jarg1, unsigned int jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mMaterialIndex = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_mMaterialIndex_get(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mMaterialIndex);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mName_set(void * jarg1, void * jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_mName_get(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMesh_mNumAnimMeshes_set(void * jarg1, unsigned int jarg2) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumAnimMeshes = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_mNumAnimMeshes_get(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int) ((arg1)->mNumAnimMeshes);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMesh() {
  void * jresult ;
  aiMesh *result = 0 ;
  
  result = (aiMesh *)new aiMesh();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMesh(void * jarg1) {
  aiMesh *arg1 = (aiMesh *) 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasPositions(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (bool)((aiMesh const *)arg1)->HasPositions();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasFaces(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (bool)((aiMesh const *)arg1)->HasFaces();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasNormals(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (bool)((aiMesh const *)arg1)->HasNormals();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasTangentsAndBitangents(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (bool)((aiMesh const *)arg1)->HasTangentsAndBitangents();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasVertexColors(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)((aiMesh const *)arg1)->HasVertexColors(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasTextureCoords(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)((aiMesh const *)arg1)->HasTextureCoords(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_GetNumUVChannels(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int)((aiMesh const *)arg1)->GetNumUVChannels();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_GetNumColorChannels(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  unsigned int result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (unsigned int)((aiMesh const *)arg1)->GetNumColorChannels();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMesh_HasBones(void * jarg1) {
  unsigned int jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  bool result;
  
  arg1 = (aiMesh *)jarg1; 
  result = (bool)((aiMesh const *)arg1)->HasBones();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmAnimMeshes(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiAnimMesh * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiAnimMesh * > *)aiMesh_GetmAnimMeshes(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmBitangents(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiVector3D * > *)aiMesh_GetmBitangents(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmBones(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiBone * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiBone * > *)aiMesh_GetmBones(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmColors(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< std::vector< aiColor4D * > > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< std::vector< aiColor4D * > > *)aiMesh_GetmColors(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmFaces(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiFace * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiFace * > *)aiMesh_GetmFaces(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmNormals(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiVector3D * > *)aiMesh_GetmNormals(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmTangents(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiVector3D * > *)aiMesh_GetmTangents(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmTextureCoords(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< std::vector< aiVector3D * > > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< std::vector< aiVector3D * > > *)aiMesh_GetmTextureCoords(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmNumUVComponents(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< unsigned int > *)aiMesh_GetmNumUVComponents(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMesh_GetmVertices(void * jarg1) {
  void * jresult ;
  aiMesh *arg1 = (aiMesh *) 0 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (aiMesh *)jarg1; 
  result = (std::vector< aiVector3D * > *)aiMesh_GetmVertices(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_DEFAULT_MATERIAL_NAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("DefaultMaterial");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AI_DEFAULT_TEXTURED_MATERIAL_NAME_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("TexturedDefaultMaterial");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiUVTransform_mTranslation_set(void * jarg1, void * jarg2) {
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  aiVector2D *arg2 = (aiVector2D *) 0 ;
  
  arg1 = (aiUVTransform *)jarg1; 
  arg2 = (aiVector2D *)jarg2; 
  if (arg1) (arg1)->mTranslation = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiUVTransform_mTranslation_get(void * jarg1) {
  void * jresult ;
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiUVTransform *)jarg1; 
  result = (aiVector2D *)& ((arg1)->mTranslation);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiUVTransform_mScaling_set(void * jarg1, void * jarg2) {
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  aiVector2D *arg2 = (aiVector2D *) 0 ;
  
  arg1 = (aiUVTransform *)jarg1; 
  arg2 = (aiVector2D *)jarg2; 
  if (arg1) (arg1)->mScaling = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiUVTransform_mScaling_get(void * jarg1) {
  void * jresult ;
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  aiVector2D *result = 0 ;
  
  arg1 = (aiUVTransform *)jarg1; 
  result = (aiVector2D *)& ((arg1)->mScaling);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiUVTransform_mRotation_set(void * jarg1, float jarg2) {
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  float arg2 ;
  
  arg1 = (aiUVTransform *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->mRotation = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiUVTransform_mRotation_get(void * jarg1) {
  float jresult ;
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  float result;
  
  arg1 = (aiUVTransform *)jarg1; 
  result = (float) ((arg1)->mRotation);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiUVTransform() {
  void * jresult ;
  aiUVTransform *result = 0 ;
  
  result = (aiUVTransform *)new aiUVTransform();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiUVTransform(void * jarg1) {
  aiUVTransform *arg1 = (aiUVTransform *) 0 ;
  
  arg1 = (aiUVTransform *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mKey_set(void * jarg1, void * jarg2) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mKey = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMaterialProperty_mKey_get(void * jarg1) {
  void * jresult ;
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  result = (aiString *)& ((arg1)->mKey);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mSemantic_set(void * jarg1, unsigned int jarg2) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mSemantic = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterialProperty_mSemantic_get(void * jarg1) {
  unsigned int jresult ;
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  unsigned int result;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  result = (unsigned int) ((arg1)->mSemantic);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mIndex_set(void * jarg1, unsigned int jarg2) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mIndex = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterialProperty_mIndex_get(void * jarg1) {
  unsigned int jresult ;
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  unsigned int result;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  result = (unsigned int) ((arg1)->mIndex);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mDataLength_set(void * jarg1, unsigned int jarg2) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mDataLength = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterialProperty_mDataLength_get(void * jarg1) {
  unsigned int jresult ;
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  unsigned int result;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  result = (unsigned int) ((arg1)->mDataLength);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mType_set(void * jarg1, int jarg2) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  aiPropertyTypeInfo arg2 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  arg2 = (aiPropertyTypeInfo)jarg2; 
  if (arg1) (arg1)->mType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterialProperty_mType_get(void * jarg1) {
  int jresult ;
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  aiPropertyTypeInfo result;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  result = (aiPropertyTypeInfo) ((arg1)->mType);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mData_set(void * jarg1, char * jarg2) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    if (arg1->mData) delete [] arg1->mData;
    if (arg2) {
      arg1->mData = (char *) (new char[strlen((const char *)arg2)+1]);
      strcpy((char *)arg1->mData, (const char *)arg2);
    } else {
      arg1->mData = 0;
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_aiMaterialProperty_mData_get(void * jarg1) {
  char * jresult ;
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  char *result = 0 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  result = (char *) ((arg1)->mData);
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMaterialProperty() {
  void * jresult ;
  aiMaterialProperty *result = 0 ;
  
  result = (aiMaterialProperty *)new aiMaterialProperty();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMaterialProperty(void * jarg1) {
  aiMaterialProperty *arg1 = (aiMaterialProperty *) 0 ;
  
  arg1 = (aiMaterialProperty *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMaterial() {
  void * jresult ;
  aiMaterial *result = 0 ;
  
  result = (aiMaterial *)new aiMaterial();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMaterial(void * jarg1) {
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  
  arg1 = (aiMaterial *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureCount(void * jarg1, int jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiTextureType arg2 ;
  unsigned int result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiTextureType)jarg2; 
  result = (unsigned int)((aiMaterial const *)arg1)->GetTextureCount(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetDiffuse(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiColor4D *arg2 = (aiColor4D *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiColor4D *)jarg2; 
  result = (bool)aiMaterial_GetDiffuse(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetSpecular(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiColor4D *arg2 = (aiColor4D *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiColor4D *)jarg2; 
  result = (bool)aiMaterial_GetSpecular(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetAmbient(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiColor4D *arg2 = (aiColor4D *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiColor4D *)jarg2; 
  result = (bool)aiMaterial_GetAmbient(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetEmissive(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiColor4D *arg2 = (aiColor4D *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiColor4D *)jarg2; 
  result = (bool)aiMaterial_GetEmissive(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetOpacity(void * jarg1, float * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  float *arg2 = (float *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (float *)jarg2; 
  result = (bool)aiMaterial_GetOpacity(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetShininessStrength(void * jarg1, float * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  float *arg2 = (float *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (float *)jarg2; 
  result = (bool)aiMaterial_GetShininessStrength(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetShadingModel(void * jarg1, int * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  int *arg2 = (int *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (int *)jarg2; 
  result = (bool)aiMaterial_GetShadingModel(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTexFlagsDiffuse0(void * jarg1, int * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  int *arg2 = (int *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (int *)jarg2; 
  result = (bool)aiMaterial_GetTexFlagsDiffuse0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetMappingModeUDiffuse0(void * jarg1, int * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  int *arg2 = (int *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (int *)jarg2; 
  result = (bool)aiMaterial_GetMappingModeUDiffuse0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetMappingModeVDiffuse0(void * jarg1, int * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  int *arg2 = (int *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (int *)jarg2; 
  result = (bool)aiMaterial_GetMappingModeVDiffuse0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureDiffuse0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureDiffuse0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureSpecular0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureSpecular0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureOpacity0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureOpacity0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureAmbient0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureAmbient0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureEmissive0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureEmissive0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureShininess0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureShininess0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureLightmap0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureLightmap0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureNormals0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureNormals0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureHeight0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetTextureHeight0(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetGlobalBackgroundImage(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (aiString *)jarg2; 
  result = (bool)aiMaterial_GetGlobalBackgroundImage(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTwoSided(void * jarg1, int * jarg2) {
  unsigned int jresult ;
  aiMaterial *arg1 = (aiMaterial *) 0 ;
  int *arg2 = (int *) 0 ;
  bool result;
  
  arg1 = (aiMaterial *)jarg1; 
  arg2 = (int *)jarg2; 
  result = (bool)aiMaterial_GetTwoSided(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_TEXTURE_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.file");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_UVWSRC_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.uvwsrc");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_TEXOP_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.op");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_MAPPING_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.mapping");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_TEXBLEND_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.blend");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_MAPPINGMODE_U_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.mapmodeu");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_MAPPINGMODE_V_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.mapmodev");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_TEXMAP_AXIS_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.mapaxis");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_UVTRANSFORM_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.uvtrafo");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_TEXFLAGS_BASE_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("$tex.flags");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_0() {
  void * jresult ;
  aiQuaternion *result = 0 ;
  
  result = (aiQuaternion *)new aiQuaternion();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  aiQuaternion *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  result = (aiQuaternion *)new aiQuaternion(arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_2(void * jarg1) {
  void * jresult ;
  aiMatrix3x3 *arg1 = 0 ;
  aiQuaternion *result = 0 ;
  
  arg1 = (aiMatrix3x3 *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 const & type is null", 0);
    return 0;
  } 
  result = (aiQuaternion *)new aiQuaternion((aiMatrix3x3 const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_3(float jarg1, float jarg2, float jarg3) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  aiQuaternion *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  result = (aiQuaternion *)new aiQuaternion(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_4(void * jarg1, float jarg2) {
  void * jresult ;
  aiVector3D arg1 ;
  float arg2 ;
  aiVector3D *argp1 ;
  aiQuaternion *result = 0 ;
  
  argp1 = (aiVector3D *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiVector3D", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (float)jarg2; 
  result = (aiQuaternion *)new aiQuaternion(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_5(void * jarg1) {
  void * jresult ;
  aiVector3D arg1 ;
  aiVector3D *argp1 ;
  aiQuaternion *result = 0 ;
  
  argp1 = (aiVector3D *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiVector3D", 0);
    return 0;
  }
  arg1 = *argp1; 
  result = (aiQuaternion *)new aiQuaternion(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_GetMatrix(void * jarg1) {
  void * jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiMatrix3x3 result;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = ((aiQuaternion const *)arg1)->GetMatrix();
  jresult = new aiMatrix3x3((const aiMatrix3x3 &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuaternion___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiQuaternion *arg2 = 0 ;
  bool result;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (aiQuaternion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiQuaternion const *)arg1)->operator ==((aiQuaternion const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuaternion___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiQuaternion *arg2 = 0 ;
  bool result;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (aiQuaternion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiQuaternion const *)arg1)->operator !=((aiQuaternion const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Normalize(void * jarg1) {
  void * jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiQuaternion *result = 0 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = (aiQuaternion *) &(arg1)->Normalize();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Conjugate(void * jarg1) {
  void * jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiQuaternion *result = 0 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = (aiQuaternion *) &(arg1)->Conjugate();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Rotate(void * jarg1, void * jarg2) {
  void * jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiVector3D *arg2 = 0 ;
  aiVector3D result;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (aiVector3D *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0);
    return 0;
  } 
  result = (arg1)->Rotate((aiVector3D const &)*arg2);
  jresult = new aiVector3D((const aiVector3D &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion___mul__(void * jarg1, void * jarg2) {
  void * jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  aiQuaternion *arg2 = 0 ;
  aiQuaternion result;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (aiQuaternion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0);
    return 0;
  } 
  result = ((aiQuaternion const *)arg1)->operator *((aiQuaternion const &)*arg2);
  jresult = new aiQuaternion((const aiQuaternion &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_Interpolate(void * jarg1, void * jarg2, void * jarg3, float jarg4) {
  aiQuaternion *arg1 = 0 ;
  aiQuaternion *arg2 = 0 ;
  aiQuaternion *arg3 = 0 ;
  float arg4 ;
  
  arg1 = (aiQuaternion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion & type is null", 0);
    return ;
  } 
  arg2 = (aiQuaternion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0);
    return ;
  } 
  arg3 = (aiQuaternion *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0);
    return ;
  } 
  arg4 = (float)jarg4; 
  aiQuaternion::Interpolate(*arg1,(aiQuaternion const &)*arg2,(aiQuaternion const &)*arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_w_set(void * jarg1, float jarg2) {
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float arg2 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->w = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_w_get(void * jarg1) {
  float jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float result;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = (float) ((arg1)->w);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_x_set(void * jarg1, float jarg2) {
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float arg2 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_x_get(void * jarg1) {
  float jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float result;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = (float) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_y_set(void * jarg1, float jarg2) {
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float arg2 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_y_get(void * jarg1) {
  float jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float result;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = (float) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_z_set(void * jarg1, float jarg2) {
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float arg2 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_z_get(void * jarg1) {
  float jresult ;
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  float result;
  
  arg1 = (aiQuaternion *)jarg1; 
  result = (float) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiQuaternion(void * jarg1) {
  aiQuaternion *arg1 = (aiQuaternion *) 0 ;
  
  arg1 = (aiQuaternion *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNode_mName_set(void * jarg1, void * jarg2) {
  aiNode *arg1 = (aiNode *) 0 ;
  aiString *arg2 = (aiString *) 0 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (aiString *)jarg2; 
  if (arg1) (arg1)->mName = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_mName_get(void * jarg1) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  aiString *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  result = (aiString *)& ((arg1)->mName);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNode_mTransformation_set(void * jarg1, void * jarg2) {
  aiNode *arg1 = (aiNode *) 0 ;
  aiMatrix4x4 *arg2 = (aiMatrix4x4 *) 0 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (aiMatrix4x4 *)jarg2; 
  if (arg1) (arg1)->mTransformation = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_mTransformation_get(void * jarg1) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  aiMatrix4x4 *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  result = (aiMatrix4x4 *)& ((arg1)->mTransformation);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNode_mParent_set(void * jarg1, void * jarg2) {
  aiNode *arg1 = (aiNode *) 0 ;
  aiNode *arg2 = (aiNode *) 0 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (aiNode *)jarg2; 
  if (arg1) (arg1)->mParent = arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_mParent_get(void * jarg1) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  aiNode *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  result = (aiNode *) ((arg1)->mParent);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNode_mNumChildren_set(void * jarg1, unsigned int jarg2) {
  aiNode *arg1 = (aiNode *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumChildren = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNode_mNumChildren_get(void * jarg1) {
  unsigned int jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  unsigned int result;
  
  arg1 = (aiNode *)jarg1; 
  result = (unsigned int) ((arg1)->mNumChildren);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNode_mNumMeshes_set(void * jarg1, unsigned int jarg2) {
  aiNode *arg1 = (aiNode *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumMeshes = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNode_mNumMeshes_get(void * jarg1) {
  unsigned int jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  unsigned int result;
  
  arg1 = (aiNode *)jarg1; 
  result = (unsigned int) ((arg1)->mNumMeshes);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNode__SWIG_0() {
  void * jresult ;
  aiNode *result = 0 ;
  
  result = (aiNode *)new aiNode();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNode__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  aiNode *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  result = (aiNode *)new aiNode((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiNode(void * jarg1) {
  aiNode *arg1 = (aiNode *) 0 ;
  
  arg1 = (aiNode *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_FindNode__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  aiString *arg2 = 0 ;
  aiNode *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (aiString *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiString const & type is null", 0);
    return 0;
  } 
  result = (aiNode *)(arg1)->FindNode((aiString const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_FindNode__SWIG_1(void * jarg1, char * jarg2) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  char *arg2 = (char *) 0 ;
  aiNode *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (aiNode *)(arg1)->FindNode((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_GetmChildren(void * jarg1) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  std::vector< aiNode * > *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  result = (std::vector< aiNode * > *)aiNode_GetmChildren(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNode_GetmMeshes(void * jarg1) {
  void * jresult ;
  aiNode *arg1 = (aiNode *) 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (aiNode *)jarg1; 
  result = (std::vector< unsigned int > *)aiNode_GetmMeshes(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SCENE_FLAGS_INCOMPLETE_get() {
  int jresult ;
  int result;
  
  result = (int)(0x1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SCENE_FLAGS_VALIDATED_get() {
  int jresult ;
  int result;
  
  result = (int)(0x2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SCENE_FLAGS_VALIDATION_WARNING_get() {
  int jresult ;
  int result;
  
  result = (int)(0x4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SCENE_FLAGS_NON_VERBOSE_FORMAT_get() {
  int jresult ;
  int result;
  
  result = (int)(0x8);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_SCENE_FLAGS_TERRAIN_get() {
  int jresult ;
  int result;
  
  result = (int)(0x10);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mFlags_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mFlags = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mFlags_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mFlags);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mRootNode_set(void * jarg1, void * jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  aiNode *arg2 = (aiNode *) 0 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (aiNode *)jarg2; 
  if (arg1) (arg1)->mRootNode = arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_mRootNode_get(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  aiNode *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (aiNode *) ((arg1)->mRootNode);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mNumMeshes_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumMeshes = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mNumMeshes_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mNumMeshes);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mNumMaterials_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumMaterials = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mNumMaterials_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mNumMaterials);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mNumAnimations_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumAnimations = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mNumAnimations_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mNumAnimations);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mNumTextures_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumTextures = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mNumTextures_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mNumTextures);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mNumLights_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumLights = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mNumLights_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mNumLights);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mNumCameras_set(void * jarg1, unsigned int jarg2) {
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiScene *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mNumCameras = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_mNumCameras_get(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  unsigned int result;
  
  arg1 = (aiScene *)jarg1; 
  result = (unsigned int) ((arg1)->mNumCameras);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiScene() {
  void * jresult ;
  aiScene *result = 0 ;
  
  result = (aiScene *)new aiScene();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiScene(void * jarg1) {
  aiScene *arg1 = (aiScene *) 0 ;
  
  arg1 = (aiScene *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasMeshes(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  bool result;
  
  arg1 = (aiScene *)jarg1; 
  result = (bool)((aiScene const *)arg1)->HasMeshes();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasMaterials(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  bool result;
  
  arg1 = (aiScene *)jarg1; 
  result = (bool)((aiScene const *)arg1)->HasMaterials();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasLights(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  bool result;
  
  arg1 = (aiScene *)jarg1; 
  result = (bool)((aiScene const *)arg1)->HasLights();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasTextures(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  bool result;
  
  arg1 = (aiScene *)jarg1; 
  result = (bool)((aiScene const *)arg1)->HasTextures();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasCameras(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  bool result;
  
  arg1 = (aiScene *)jarg1; 
  result = (bool)((aiScene const *)arg1)->HasCameras();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasAnimations(void * jarg1) {
  unsigned int jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  bool result;
  
  arg1 = (aiScene *)jarg1; 
  result = (bool)((aiScene const *)arg1)->HasAnimations();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmAnimations(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  std::vector< aiAnimation * > *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (std::vector< aiAnimation * > *)aiScene_GetmAnimations(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmCameras(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  std::vector< aiCamera * > *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (std::vector< aiCamera * > *)aiScene_GetmCameras(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmLights(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  std::vector< aiLight * > *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (std::vector< aiLight * > *)aiScene_GetmLights(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmMaterials(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  std::vector< aiMaterial * > *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (std::vector< aiMaterial * > *)aiScene_GetmMaterials(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmMeshes(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  std::vector< aiMesh * > *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (std::vector< aiMesh * > *)aiScene_GetmMeshes(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmTextures(void * jarg1) {
  void * jresult ;
  aiScene *arg1 = (aiScene *) 0 ;
  std::vector< aiTexture * > *result = 0 ;
  
  arg1 = (aiScene *)jarg1; 
  result = (std::vector< aiTexture * > *)aiScene_GetmTextures(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexel_b_set(void * jarg1, unsigned char jarg2) {
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char arg2 ;
  
  arg1 = (aiTexel *)jarg1; 
  arg2 = (unsigned char)jarg2; 
  if (arg1) (arg1)->b = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_aiTexel_b_get(void * jarg1) {
  unsigned char jresult ;
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char result;
  
  arg1 = (aiTexel *)jarg1; 
  result = (unsigned char) ((arg1)->b);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexel_g_set(void * jarg1, unsigned char jarg2) {
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char arg2 ;
  
  arg1 = (aiTexel *)jarg1; 
  arg2 = (unsigned char)jarg2; 
  if (arg1) (arg1)->g = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_aiTexel_g_get(void * jarg1) {
  unsigned char jresult ;
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char result;
  
  arg1 = (aiTexel *)jarg1; 
  result = (unsigned char) ((arg1)->g);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexel_r_set(void * jarg1, unsigned char jarg2) {
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char arg2 ;
  
  arg1 = (aiTexel *)jarg1; 
  arg2 = (unsigned char)jarg2; 
  if (arg1) (arg1)->r = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_aiTexel_r_get(void * jarg1) {
  unsigned char jresult ;
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char result;
  
  arg1 = (aiTexel *)jarg1; 
  result = (unsigned char) ((arg1)->r);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexel_a_set(void * jarg1, unsigned char jarg2) {
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char arg2 ;
  
  arg1 = (aiTexel *)jarg1; 
  arg2 = (unsigned char)jarg2; 
  if (arg1) (arg1)->a = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_aiTexel_a_get(void * jarg1) {
  unsigned char jresult ;
  aiTexel *arg1 = (aiTexel *) 0 ;
  unsigned char result;
  
  arg1 = (aiTexel *)jarg1; 
  result = (unsigned char) ((arg1)->a);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTexel___equal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiTexel *arg1 = (aiTexel *) 0 ;
  aiTexel *arg2 = 0 ;
  bool result;
  
  arg1 = (aiTexel *)jarg1; 
  arg2 = (aiTexel *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiTexel const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiTexel const *)arg1)->operator ==((aiTexel const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTexel___nequal__(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  aiTexel *arg1 = (aiTexel *) 0 ;
  aiTexel *arg2 = 0 ;
  bool result;
  
  arg1 = (aiTexel *)jarg1; 
  arg2 = (aiTexel *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiTexel const & type is null", 0);
    return 0;
  } 
  result = (bool)((aiTexel const *)arg1)->operator !=((aiTexel const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiTexel() {
  void * jresult ;
  aiTexel *result = 0 ;
  
  result = (aiTexel *)new aiTexel();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiTexel(void * jarg1) {
  aiTexel *arg1 = (aiTexel *) 0 ;
  
  arg1 = (aiTexel *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexture_mWidth_set(void * jarg1, unsigned int jarg2) {
  aiTexture *arg1 = (aiTexture *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiTexture *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mWidth = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTexture_mWidth_get(void * jarg1) {
  unsigned int jresult ;
  aiTexture *arg1 = (aiTexture *) 0 ;
  unsigned int result;
  
  arg1 = (aiTexture *)jarg1; 
  result = (unsigned int) ((arg1)->mWidth);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexture_mHeight_set(void * jarg1, unsigned int jarg2) {
  aiTexture *arg1 = (aiTexture *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (aiTexture *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->mHeight = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTexture_mHeight_get(void * jarg1) {
  unsigned int jresult ;
  aiTexture *arg1 = (aiTexture *) 0 ;
  unsigned int result;
  
  arg1 = (aiTexture *)jarg1; 
  result = (unsigned int) ((arg1)->mHeight);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexture_achFormatHint_set(void * jarg1, char * jarg2) {
  aiTexture *arg1 = (aiTexture *) 0 ;
  char *arg2 ;
  
  arg1 = (aiTexture *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    if(arg2) {
      strncpy((char*)arg1->achFormatHint, (const char *)arg2, 4-1);
      arg1->achFormatHint[4-1] = 0;
    } else {
      arg1->achFormatHint[0] = 0;
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_aiTexture_achFormatHint_get(void * jarg1) {
  char * jresult ;
  aiTexture *arg1 = (aiTexture *) 0 ;
  char *result = 0 ;
  
  arg1 = (aiTexture *)jarg1; 
  result = (char *)(char *) ((arg1)->achFormatHint);
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTexture_pcData_set(void * jarg1, void * jarg2) {
  aiTexture *arg1 = (aiTexture *) 0 ;
  aiTexel *arg2 = (aiTexel *) 0 ;
  
  arg1 = (aiTexture *)jarg1; 
  arg2 = (aiTexel *)jarg2; 
  if (arg1) (arg1)->pcData = arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiTexture_pcData_get(void * jarg1) {
  void * jresult ;
  aiTexture *arg1 = (aiTexture *) 0 ;
  aiTexel *result = 0 ;
  
  arg1 = (aiTexture *)jarg1; 
  result = (aiTexel *) ((arg1)->pcData);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTexture_CheckFormat(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  aiTexture *arg1 = (aiTexture *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (aiTexture *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)((aiTexture const *)arg1)->CheckFormat((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiTexture() {
  void * jresult ;
  aiTexture *result = 0 ;
  
  result = (aiTexture *)new aiTexture();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiTexture(void * jarg1) {
  aiTexture *arg1 = (aiTexture *) 0 ;
  
  arg1 = (aiTexture *)jarg1; 
  delete arg1;
}


SWIGEXPORT int SWIGSTDCALL CSharp_AI_PROPERTY_WAS_NOT_EXISTING_get() {
  int jresult ;
  int result;
  
  result = (int)(0xffffffff);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiImportFileFromMemory(char * jarg1, unsigned int jarg2, unsigned int jarg3, char * jarg4) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  char *arg4 = (char *) 0 ;
  aiScene *result = 0 ;
  
  arg1 = (char *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  arg3 = (unsigned int)jarg3; 
  arg4 = (char *)jarg4; 
  result = (aiScene *)aiImportFileFromMemory((char const *)arg1,arg2,arg3,(char const *)arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Importer__SWIG_0() {
  void * jresult ;
  Assimp::Importer *result = 0 ;
  
  result = (Assimp::Importer *)new Assimp::Importer();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Importer__SWIG_1(void * jarg1) {
  void * jresult ;
  Assimp::Importer *arg1 = 0 ;
  Assimp::Importer *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Assimp::Importer const & type is null", 0);
    return 0;
  } 
  result = (Assimp::Importer *)new Assimp::Importer((Assimp::Importer const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Importer(void * jarg1) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  delete arg1;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Importer_GetPropertyInteger__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
  int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (int)((Assimp::Importer const *)arg1)->GetPropertyInteger((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Importer_GetPropertyInteger__SWIG_1(void * jarg1, char * jarg2) {
  int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  int result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (int)((Assimp::Importer const *)arg1)->GetPropertyInteger((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_GetPropertyBool__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  bool result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (bool)((Assimp::Importer const *)arg1)->GetPropertyBool((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_GetPropertyBool__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)((Assimp::Importer const *)arg1)->GetPropertyBool((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_Importer_GetPropertyFloat__SWIG_0(void * jarg1, char * jarg2, float jarg3) {
  float jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  float arg3 ;
  float result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (float)jarg3; 
  result = (float)((Assimp::Importer const *)arg1)->GetPropertyFloat((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_Importer_GetPropertyFloat__SWIG_1(void * jarg1, char * jarg2) {
  float jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  float result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (float)((Assimp::Importer const *)arg1)->GetPropertyFloat((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Importer_GetPropertyString__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  char * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string *arg3 = 0 ;
  std::string *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = (std::string *) &((Assimp::Importer const *)arg1)->GetPropertyString((char const *)arg2,(std::string const &)*arg3);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Importer_GetPropertyString__SWIG_1(void * jarg1, char * jarg2) {
  char * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (std::string *) &((Assimp::Importer const *)arg1)->GetPropertyString((char const *)arg2);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_IsDefaultIOHandler(void * jarg1) {
  unsigned int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  bool result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = (bool)((Assimp::Importer const *)arg1)->IsDefaultIOHandler();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Importer_SetProgressHandler(void * jarg1, void * jarg2) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  Assimp::ProgressHandler *arg2 = (Assimp::ProgressHandler *) 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (Assimp::ProgressHandler *)jarg2; 
  (arg1)->SetProgressHandler(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetProgressHandler(void * jarg1) {
  void * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  Assimp::ProgressHandler *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = (Assimp::ProgressHandler *)((Assimp::Importer const *)arg1)->GetProgressHandler();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_IsDefaultProgressHandler(void * jarg1) {
  unsigned int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  bool result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = (bool)((Assimp::Importer const *)arg1)->IsDefaultProgressHandler();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_ValidateFlags(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)((Assimp::Importer const *)arg1)->ValidateFlags(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_ReadFile__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  aiScene *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (unsigned int)jarg3; 
  result = (aiScene *)(arg1)->ReadFile((char const *)arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Importer_FreeScene(void * jarg1) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  (arg1)->FreeScene();
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Importer_GetErrorString(void * jarg1) {
  char * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = (char *)((Assimp::Importer const *)arg1)->GetErrorString();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_IsExtensionSupported__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)((Assimp::Importer const *)arg1)->IsExtensionSupported((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Importer_GetExtensionList__SWIG_0(void * jarg1, void * jarg2) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  aiString *arg2 = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (aiString *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiString & type is null", 0);
    return ;
  } 
  ((Assimp::Importer const *)arg1)->GetExtensionList(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Importer_GetExtensionList__SWIG_1(void * jarg1, void * jarg2) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (std::string *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0);
    return ;
  } 
  ((Assimp::Importer const *)arg1)->GetExtensionList(*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetScene(void * jarg1) {
  void * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  aiScene *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = (aiScene *)((Assimp::Importer const *)arg1)->GetScene();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetOrphanedScene(void * jarg1) {
  void * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  aiScene *result = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = (aiScene *)(arg1)->GetOrphanedScene();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Importer_GetMemoryRequirements(void * jarg1, void * jarg2) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  aiMemoryInfo *arg2 = 0 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = (aiMemoryInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMemoryInfo & type is null", 0);
    return ;
  } 
  ((Assimp::Importer const *)arg1)->GetMemoryRequirements(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Importer_SetExtraVerbose(void * jarg1, unsigned int jarg2) {
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  bool arg2 ;
  
  arg1 = (Assimp::Importer *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->SetExtraVerbose(arg2);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Importer_GetExtensionList__SWIG_2(void * jarg1) {
  char * jresult ;
  Assimp::Importer *arg1 = (Assimp::Importer *) 0 ;
  std::string result;
  
  arg1 = (Assimp::Importer *)jarg1; 
  result = Assimp_Importer_GetExtensionList__SWIG_2(arg1);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ProgressHandler(void * jarg1) {
  Assimp::ProgressHandler *arg1 = (Assimp::ProgressHandler *) 0 ;
  
  arg1 = (Assimp::ProgressHandler *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ProgressHandler_Update__SWIG_0(void * jarg1, float jarg2) {
  unsigned int jresult ;
  Assimp::ProgressHandler *arg1 = (Assimp::ProgressHandler *) 0 ;
  float arg2 ;
  bool result;
  
  arg1 = (Assimp::ProgressHandler *)jarg1; 
  arg2 = (float)jarg2; 
  result = (bool)(arg1)->Update(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ProgressHandler_Update__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  Assimp::ProgressHandler *arg1 = (Assimp::ProgressHandler *) 0 ;
  bool result;
  
  arg1 = (Assimp::ProgressHandler *)jarg1; 
  result = (bool)(arg1)->Update();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_Clear(void * jarg1) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_Add(void * jarg1, float jarg2) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->push_back((float const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_FloatVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  std::vector< float >::size_type result;
  
  arg1 = (std::vector< float > *)jarg1; 
  result = ((std::vector< float > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_FloatVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  std::vector< float >::size_type result;
  
  arg1 = (std::vector< float > *)jarg1; 
  result = ((std::vector< float > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  std::vector< float >::size_type arg2 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (std::vector< float >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FloatVector__SWIG_0() {
  void * jresult ;
  std::vector< float > *result = 0 ;
  
  result = (std::vector< float > *)new std::vector< float >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FloatVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< float > *arg1 = 0 ;
  std::vector< float > *result = 0 ;
  
  arg1 = (std::vector< float > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< float > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FloatVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< float > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< float > *)new_std_vector_Sl_float_Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_FloatVector_getitemcopy(void * jarg1, int jarg2) {
  float jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  float result;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (float)std_vector_Sl_float_Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_FloatVector_getitem(void * jarg1, int jarg2) {
  float jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  float *result = 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (float *) &std_vector_Sl_float_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_setitem(void * jarg1, int jarg2, float jarg3) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  float temp3 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (float)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_float_Sg__setitem(arg1,arg2,(float const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  std::vector< float > *arg2 = 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (std::vector< float > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< float > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_float_Sg__AddRange(arg1,(std::vector< float > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FloatVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< float > *result = 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< float > *)std_vector_Sl_float_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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_Insert(void * jarg1, int jarg2, float jarg3) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  float temp3 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (float)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_float_Sg__Insert(arg1,arg2,(float const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  std::vector< float > *arg3 = 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< float > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< float > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_float_Sg__InsertRange(arg1,arg2,(std::vector< float > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_float_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_float_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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FloatVector_Repeat(float jarg1, int jarg2) {
  void * jresult ;
  float *arg1 = 0 ;
  int arg2 ;
  float temp1 ;
  std::vector< float > *result = 0 ;
  
  temp1 = (float)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< float > *)std_vector_Sl_float_Sg__Repeat((float const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  std_vector_Sl_float_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_float_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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  int arg2 ;
  std::vector< float > *arg3 = 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< float > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< float > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_float_Sg__SetRange(arg1,arg2,(std::vector< float > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FloatVector_Contains(void * jarg1, float jarg2) {
  unsigned int jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  bool result;
  
  arg1 = (std::vector< float > *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_float_Sg__Contains(arg1,(float const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_FloatVector_IndexOf(void * jarg1, float jarg2) {
  int jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  int result;
  
  arg1 = (std::vector< float > *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_float_Sg__IndexOf(arg1,(float const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_FloatVector_LastIndexOf(void * jarg1, float jarg2) {
  int jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  int result;
  
  arg1 = (std::vector< float > *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_float_Sg__LastIndexOf(arg1,(float const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FloatVector_Remove(void * jarg1, float jarg2) {
  unsigned int jresult ;
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  bool result;
  
  arg1 = (std::vector< float > *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_float_Sg__Remove(arg1,(float const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_FloatVector(void * jarg1) {
  std::vector< float > *arg1 = (std::vector< float > *) 0 ;
  
  arg1 = (std::vector< float > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_Clear(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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; 
  (arg1)->push_back((unsigned int const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_UintVector_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; 
  result = ((std::vector< unsigned int > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_UintVector_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; 
  result = ((std::vector< unsigned int > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UintVector__SWIG_0() {
  void * jresult ;
  std::vector< unsigned int > *result = 0 ;
  
  result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UintVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UintVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UintVector_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 {
    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;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UintVector_getitem(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  unsigned int *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UintVector_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 {
    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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  try {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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 {
    std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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 {
    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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UintVector_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 {
    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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_UintVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  try {
    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 ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UintVector_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; 
  result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_UintVector_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; 
  result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_UintVector_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; 
  result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UintVector_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; 
  result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_UintVector(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_Clear(void * jarg1) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  aiAnimation **arg2 = 0 ;
  aiAnimation *temp2 = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  temp2 = (aiAnimation *)jarg2;
  arg2 = (aiAnimation **)&temp2; 
  (arg1)->push_back((aiAnimation *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiAnimationVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  std::vector< aiAnimation * >::size_type result;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  result = ((std::vector< aiAnimation * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiAnimationVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  std::vector< aiAnimation * >::size_type result;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  result = ((std::vector< aiAnimation * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  std::vector< aiAnimation * >::size_type arg2 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (std::vector< aiAnimation * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimationVector__SWIG_0() {
  void * jresult ;
  std::vector< aiAnimation * > *result = 0 ;
  
  result = (std::vector< aiAnimation * > *)new std::vector< aiAnimation * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimationVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiAnimation * > *arg1 = 0 ;
  std::vector< aiAnimation * > *result = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimation * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiAnimation * > *)new std::vector< aiAnimation * >((std::vector< aiAnimation * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimationVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiAnimation * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiAnimation * > *)new_std_vector_Sl_aiAnimation_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimationVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  aiAnimation *result = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiAnimation *)std_vector_Sl_aiAnimation_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimationVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  aiAnimation **result = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiAnimation **) &std_vector_Sl_aiAnimation_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  aiAnimation **arg3 = 0 ;
  aiAnimation *temp3 = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiAnimation *)jarg3;
  arg3 = (aiAnimation **)&temp3; 
  try {
    std_vector_Sl_aiAnimation_Sm__Sg__setitem(arg1,arg2,(aiAnimation *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  std::vector< aiAnimation * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (std::vector< aiAnimation * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimation * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiAnimation_Sm__Sg__AddRange(arg1,(std::vector< aiAnimation * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimationVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiAnimation * > *result = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiAnimation * > *)std_vector_Sl_aiAnimation_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  aiAnimation **arg3 = 0 ;
  aiAnimation *temp3 = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiAnimation *)jarg3;
  arg3 = (aiAnimation **)&temp3; 
  try {
    std_vector_Sl_aiAnimation_Sm__Sg__Insert(arg1,arg2,(aiAnimation *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  std::vector< aiAnimation * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiAnimation * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimation * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiAnimation_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiAnimation * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiAnimation_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiAnimation_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimationVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiAnimation **arg1 = 0 ;
  int arg2 ;
  aiAnimation *temp1 = 0 ;
  std::vector< aiAnimation * > *result = 0 ;
  
  temp1 = (aiAnimation *)jarg1;
  arg1 = (aiAnimation **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiAnimation * > *)std_vector_Sl_aiAnimation_Sm__Sg__Repeat((aiAnimation *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  std_vector_Sl_aiAnimation_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiAnimation_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimationVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  int arg2 ;
  std::vector< aiAnimation * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiAnimation * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimation * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiAnimation_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiAnimation * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimationVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  aiAnimation **arg2 = 0 ;
  aiAnimation *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  temp2 = (aiAnimation *)jarg2;
  arg2 = (aiAnimation **)&temp2; 
  result = (bool)std_vector_Sl_aiAnimation_Sm__Sg__Contains(arg1,(aiAnimation *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiAnimationVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  aiAnimation **arg2 = 0 ;
  aiAnimation *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  temp2 = (aiAnimation *)jarg2;
  arg2 = (aiAnimation **)&temp2; 
  result = (int)std_vector_Sl_aiAnimation_Sm__Sg__IndexOf(arg1,(aiAnimation *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiAnimationVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  aiAnimation **arg2 = 0 ;
  aiAnimation *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  temp2 = (aiAnimation *)jarg2;
  arg2 = (aiAnimation **)&temp2; 
  result = (int)std_vector_Sl_aiAnimation_Sm__Sg__LastIndexOf(arg1,(aiAnimation *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimationVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  aiAnimation **arg2 = 0 ;
  aiAnimation *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  temp2 = (aiAnimation *)jarg2;
  arg2 = (aiAnimation **)&temp2; 
  result = (bool)std_vector_Sl_aiAnimation_Sm__Sg__Remove(arg1,(aiAnimation *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiAnimationVector(void * jarg1) {
  std::vector< aiAnimation * > *arg1 = (std::vector< aiAnimation * > *) 0 ;
  
  arg1 = (std::vector< aiAnimation * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_Clear(void * jarg1) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  aiAnimMesh **arg2 = 0 ;
  aiAnimMesh *temp2 = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  temp2 = (aiAnimMesh *)jarg2;
  arg2 = (aiAnimMesh **)&temp2; 
  (arg1)->push_back((aiAnimMesh *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiAnimMeshVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  std::vector< aiAnimMesh * >::size_type result;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  result = ((std::vector< aiAnimMesh * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiAnimMeshVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  std::vector< aiAnimMesh * >::size_type result;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  result = ((std::vector< aiAnimMesh * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  std::vector< aiAnimMesh * >::size_type arg2 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (std::vector< aiAnimMesh * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimMeshVector__SWIG_0() {
  void * jresult ;
  std::vector< aiAnimMesh * > *result = 0 ;
  
  result = (std::vector< aiAnimMesh * > *)new std::vector< aiAnimMesh * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimMeshVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiAnimMesh * > *arg1 = 0 ;
  std::vector< aiAnimMesh * > *result = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimMesh * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiAnimMesh * > *)new std::vector< aiAnimMesh * >((std::vector< aiAnimMesh * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiAnimMeshVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiAnimMesh * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiAnimMesh * > *)new_std_vector_Sl_aiAnimMesh_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimMeshVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  aiAnimMesh *result = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiAnimMesh *)std_vector_Sl_aiAnimMesh_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimMeshVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  aiAnimMesh **result = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiAnimMesh **) &std_vector_Sl_aiAnimMesh_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  aiAnimMesh **arg3 = 0 ;
  aiAnimMesh *temp3 = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiAnimMesh *)jarg3;
  arg3 = (aiAnimMesh **)&temp3; 
  try {
    std_vector_Sl_aiAnimMesh_Sm__Sg__setitem(arg1,arg2,(aiAnimMesh *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  std::vector< aiAnimMesh * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (std::vector< aiAnimMesh * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimMesh * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiAnimMesh_Sm__Sg__AddRange(arg1,(std::vector< aiAnimMesh * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimMeshVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiAnimMesh * > *result = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiAnimMesh * > *)std_vector_Sl_aiAnimMesh_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  aiAnimMesh **arg3 = 0 ;
  aiAnimMesh *temp3 = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiAnimMesh *)jarg3;
  arg3 = (aiAnimMesh **)&temp3; 
  try {
    std_vector_Sl_aiAnimMesh_Sm__Sg__Insert(arg1,arg2,(aiAnimMesh *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  std::vector< aiAnimMesh * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiAnimMesh * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimMesh * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiAnimMesh_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiAnimMesh * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiAnimMesh_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiAnimMesh_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiAnimMeshVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiAnimMesh **arg1 = 0 ;
  int arg2 ;
  aiAnimMesh *temp1 = 0 ;
  std::vector< aiAnimMesh * > *result = 0 ;
  
  temp1 = (aiAnimMesh *)jarg1;
  arg1 = (aiAnimMesh **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiAnimMesh * > *)std_vector_Sl_aiAnimMesh_Sm__Sg__Repeat((aiAnimMesh *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  std_vector_Sl_aiAnimMesh_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiAnimMesh_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiAnimMeshVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  int arg2 ;
  std::vector< aiAnimMesh * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiAnimMesh * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiAnimMesh * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiAnimMesh_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiAnimMesh * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMeshVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  aiAnimMesh **arg2 = 0 ;
  aiAnimMesh *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  temp2 = (aiAnimMesh *)jarg2;
  arg2 = (aiAnimMesh **)&temp2; 
  result = (bool)std_vector_Sl_aiAnimMesh_Sm__Sg__Contains(arg1,(aiAnimMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiAnimMeshVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  aiAnimMesh **arg2 = 0 ;
  aiAnimMesh *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  temp2 = (aiAnimMesh *)jarg2;
  arg2 = (aiAnimMesh **)&temp2; 
  result = (int)std_vector_Sl_aiAnimMesh_Sm__Sg__IndexOf(arg1,(aiAnimMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiAnimMeshVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  aiAnimMesh **arg2 = 0 ;
  aiAnimMesh *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  temp2 = (aiAnimMesh *)jarg2;
  arg2 = (aiAnimMesh **)&temp2; 
  result = (int)std_vector_Sl_aiAnimMesh_Sm__Sg__LastIndexOf(arg1,(aiAnimMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiAnimMeshVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  aiAnimMesh **arg2 = 0 ;
  aiAnimMesh *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  temp2 = (aiAnimMesh *)jarg2;
  arg2 = (aiAnimMesh **)&temp2; 
  result = (bool)std_vector_Sl_aiAnimMesh_Sm__Sg__Remove(arg1,(aiAnimMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiAnimMeshVector(void * jarg1) {
  std::vector< aiAnimMesh * > *arg1 = (std::vector< aiAnimMesh * > *) 0 ;
  
  arg1 = (std::vector< aiAnimMesh * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_Clear(void * jarg1) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  aiBone **arg2 = 0 ;
  aiBone *temp2 = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  temp2 = (aiBone *)jarg2;
  arg2 = (aiBone **)&temp2; 
  (arg1)->push_back((aiBone *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiBoneVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  std::vector< aiBone * >::size_type result;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  result = ((std::vector< aiBone * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiBoneVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  std::vector< aiBone * >::size_type result;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  result = ((std::vector< aiBone * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  std::vector< aiBone * >::size_type arg2 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (std::vector< aiBone * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiBoneVector__SWIG_0() {
  void * jresult ;
  std::vector< aiBone * > *result = 0 ;
  
  result = (std::vector< aiBone * > *)new std::vector< aiBone * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiBoneVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiBone * > *arg1 = 0 ;
  std::vector< aiBone * > *result = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiBone * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiBone * > *)new std::vector< aiBone * >((std::vector< aiBone * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiBoneVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiBone * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiBone * > *)new_std_vector_Sl_aiBone_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBoneVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  aiBone *result = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiBone *)std_vector_Sl_aiBone_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBoneVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  aiBone **result = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiBone **) &std_vector_Sl_aiBone_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  aiBone **arg3 = 0 ;
  aiBone *temp3 = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiBone *)jarg3;
  arg3 = (aiBone **)&temp3; 
  try {
    std_vector_Sl_aiBone_Sm__Sg__setitem(arg1,arg2,(aiBone *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  std::vector< aiBone * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (std::vector< aiBone * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiBone * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiBone_Sm__Sg__AddRange(arg1,(std::vector< aiBone * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBoneVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiBone * > *result = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiBone * > *)std_vector_Sl_aiBone_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  aiBone **arg3 = 0 ;
  aiBone *temp3 = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiBone *)jarg3;
  arg3 = (aiBone **)&temp3; 
  try {
    std_vector_Sl_aiBone_Sm__Sg__Insert(arg1,arg2,(aiBone *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  std::vector< aiBone * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiBone * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiBone * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiBone_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiBone * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiBone_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiBone_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiBoneVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiBone **arg1 = 0 ;
  int arg2 ;
  aiBone *temp1 = 0 ;
  std::vector< aiBone * > *result = 0 ;
  
  temp1 = (aiBone *)jarg1;
  arg1 = (aiBone **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiBone * > *)std_vector_Sl_aiBone_Sm__Sg__Repeat((aiBone *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  std_vector_Sl_aiBone_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiBone_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiBoneVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  int arg2 ;
  std::vector< aiBone * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiBone * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiBone * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiBone_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiBone * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiBoneVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  aiBone **arg2 = 0 ;
  aiBone *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  temp2 = (aiBone *)jarg2;
  arg2 = (aiBone **)&temp2; 
  result = (bool)std_vector_Sl_aiBone_Sm__Sg__Contains(arg1,(aiBone *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiBoneVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  aiBone **arg2 = 0 ;
  aiBone *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  temp2 = (aiBone *)jarg2;
  arg2 = (aiBone **)&temp2; 
  result = (int)std_vector_Sl_aiBone_Sm__Sg__IndexOf(arg1,(aiBone *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiBoneVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  aiBone **arg2 = 0 ;
  aiBone *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  temp2 = (aiBone *)jarg2;
  arg2 = (aiBone **)&temp2; 
  result = (int)std_vector_Sl_aiBone_Sm__Sg__LastIndexOf(arg1,(aiBone *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiBoneVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  aiBone **arg2 = 0 ;
  aiBone *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  temp2 = (aiBone *)jarg2;
  arg2 = (aiBone **)&temp2; 
  result = (bool)std_vector_Sl_aiBone_Sm__Sg__Remove(arg1,(aiBone *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiBoneVector(void * jarg1) {
  std::vector< aiBone * > *arg1 = (std::vector< aiBone * > *) 0 ;
  
  arg1 = (std::vector< aiBone * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_Clear(void * jarg1) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  aiCamera **arg2 = 0 ;
  aiCamera *temp2 = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  temp2 = (aiCamera *)jarg2;
  arg2 = (aiCamera **)&temp2; 
  (arg1)->push_back((aiCamera *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiCameraVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  std::vector< aiCamera * >::size_type result;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  result = ((std::vector< aiCamera * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiCameraVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  std::vector< aiCamera * >::size_type result;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  result = ((std::vector< aiCamera * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  std::vector< aiCamera * >::size_type arg2 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (std::vector< aiCamera * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiCameraVector__SWIG_0() {
  void * jresult ;
  std::vector< aiCamera * > *result = 0 ;
  
  result = (std::vector< aiCamera * > *)new std::vector< aiCamera * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiCameraVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiCamera * > *arg1 = 0 ;
  std::vector< aiCamera * > *result = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiCamera * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiCamera * > *)new std::vector< aiCamera * >((std::vector< aiCamera * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiCameraVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiCamera * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiCamera * > *)new_std_vector_Sl_aiCamera_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCameraVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  aiCamera *result = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiCamera *)std_vector_Sl_aiCamera_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCameraVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  aiCamera **result = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiCamera **) &std_vector_Sl_aiCamera_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  aiCamera **arg3 = 0 ;
  aiCamera *temp3 = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiCamera *)jarg3;
  arg3 = (aiCamera **)&temp3; 
  try {
    std_vector_Sl_aiCamera_Sm__Sg__setitem(arg1,arg2,(aiCamera *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  std::vector< aiCamera * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (std::vector< aiCamera * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiCamera * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiCamera_Sm__Sg__AddRange(arg1,(std::vector< aiCamera * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCameraVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiCamera * > *result = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiCamera * > *)std_vector_Sl_aiCamera_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  aiCamera **arg3 = 0 ;
  aiCamera *temp3 = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiCamera *)jarg3;
  arg3 = (aiCamera **)&temp3; 
  try {
    std_vector_Sl_aiCamera_Sm__Sg__Insert(arg1,arg2,(aiCamera *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  std::vector< aiCamera * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiCamera * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiCamera * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiCamera_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiCamera * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiCamera_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiCamera_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiCameraVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiCamera **arg1 = 0 ;
  int arg2 ;
  aiCamera *temp1 = 0 ;
  std::vector< aiCamera * > *result = 0 ;
  
  temp1 = (aiCamera *)jarg1;
  arg1 = (aiCamera **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiCamera * > *)std_vector_Sl_aiCamera_Sm__Sg__Repeat((aiCamera *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  std_vector_Sl_aiCamera_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiCamera_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiCameraVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  int arg2 ;
  std::vector< aiCamera * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiCamera * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiCamera * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiCamera_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiCamera * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiCameraVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  aiCamera **arg2 = 0 ;
  aiCamera *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  temp2 = (aiCamera *)jarg2;
  arg2 = (aiCamera **)&temp2; 
  result = (bool)std_vector_Sl_aiCamera_Sm__Sg__Contains(arg1,(aiCamera *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiCameraVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  aiCamera **arg2 = 0 ;
  aiCamera *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  temp2 = (aiCamera *)jarg2;
  arg2 = (aiCamera **)&temp2; 
  result = (int)std_vector_Sl_aiCamera_Sm__Sg__IndexOf(arg1,(aiCamera *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiCameraVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  aiCamera **arg2 = 0 ;
  aiCamera *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  temp2 = (aiCamera *)jarg2;
  arg2 = (aiCamera **)&temp2; 
  result = (int)std_vector_Sl_aiCamera_Sm__Sg__LastIndexOf(arg1,(aiCamera *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiCameraVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  aiCamera **arg2 = 0 ;
  aiCamera *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  temp2 = (aiCamera *)jarg2;
  arg2 = (aiCamera **)&temp2; 
  result = (bool)std_vector_Sl_aiCamera_Sm__Sg__Remove(arg1,(aiCamera *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiCameraVector(void * jarg1) {
  std::vector< aiCamera * > *arg1 = (std::vector< aiCamera * > *) 0 ;
  
  arg1 = (std::vector< aiCamera * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Clear(void * jarg1) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  std::vector< aiColor4D * > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (std::vector< aiColor4D * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return ;
  } 
  (arg1)->push_back((std::vector< aiColor4D * > const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVectorVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  std::vector< std::vector< aiColor4D * > >::size_type result;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  result = ((std::vector< std::vector< aiColor4D * > > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVectorVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  std::vector< std::vector< aiColor4D * > >::size_type result;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  result = ((std::vector< std::vector< aiColor4D * > > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  std::vector< std::vector< aiColor4D * > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (std::vector< std::vector< aiColor4D * > >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4DVectorVector__SWIG_0() {
  void * jresult ;
  std::vector< std::vector< aiColor4D * > > *result = 0 ;
  
  result = (std::vector< std::vector< aiColor4D * > > *)new std::vector< std::vector< aiColor4D * > >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4DVectorVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< aiColor4D * > > *arg1 = 0 ;
  std::vector< std::vector< aiColor4D * > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< std::vector< aiColor4D * > > *)new std::vector< std::vector< aiColor4D * > >((std::vector< std::vector< aiColor4D * > > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4DVectorVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< aiColor4D * > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< std::vector< aiColor4D * > > *)new_std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  std::vector< aiColor4D * > result;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = new std::vector< aiColor4D * >((const std::vector< aiColor4D * > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  std::vector< aiColor4D * > *result = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiColor4D * > *) &std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  std::vector< aiColor4D * > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiColor4D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__setitem(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  std::vector< std::vector< aiColor4D * > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (std::vector< std::vector< aiColor4D * > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__AddRange(arg1,(std::vector< std::vector< aiColor4D * > > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< aiColor4D * > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< std::vector< aiColor4D * > > *)std_vector_Sl_std_vector_Sl_aiColor4D_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  std::vector< aiColor4D * > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiColor4D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Insert(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< aiColor4D * > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< aiColor4D * > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< aiColor4D * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiColor4D * > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< aiColor4D * > > *result = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::vector< aiColor4D * > > *)std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Repeat((std::vector< aiColor4D * > const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< aiColor4D * > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< aiColor4D * > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< aiColor4D * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiColor4DVectorVector(void * jarg1) {
  std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ;
  
  arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Clear(void * jarg1) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  aiColor4D **arg2 = 0 ;
  aiColor4D *temp2 = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  temp2 = (aiColor4D *)jarg2;
  arg2 = (aiColor4D **)&temp2; 
  (arg1)->push_back((aiColor4D *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  std::vector< aiColor4D * >::size_type result;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  result = ((std::vector< aiColor4D * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  std::vector< aiColor4D * >::size_type result;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  result = ((std::vector< aiColor4D * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  std::vector< aiColor4D * >::size_type arg2 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (std::vector< aiColor4D * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4DVector__SWIG_0() {
  void * jresult ;
  std::vector< aiColor4D * > *result = 0 ;
  
  result = (std::vector< aiColor4D * > *)new std::vector< aiColor4D * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4DVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiColor4D * > *arg1 = 0 ;
  std::vector< aiColor4D * > *result = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiColor4D * > *)new std::vector< aiColor4D * >((std::vector< aiColor4D * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4DVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiColor4D * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiColor4D * > *)new_std_vector_Sl_aiColor4D_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  aiColor4D *result = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiColor4D *)std_vector_Sl_aiColor4D_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  aiColor4D **result = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiColor4D **) &std_vector_Sl_aiColor4D_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  aiColor4D **arg3 = 0 ;
  aiColor4D *temp3 = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiColor4D *)jarg3;
  arg3 = (aiColor4D **)&temp3; 
  try {
    std_vector_Sl_aiColor4D_Sm__Sg__setitem(arg1,arg2,(aiColor4D *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  std::vector< aiColor4D * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (std::vector< aiColor4D * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiColor4D_Sm__Sg__AddRange(arg1,(std::vector< aiColor4D * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiColor4D * > *result = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiColor4D * > *)std_vector_Sl_aiColor4D_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  aiColor4D **arg3 = 0 ;
  aiColor4D *temp3 = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiColor4D *)jarg3;
  arg3 = (aiColor4D **)&temp3; 
  try {
    std_vector_Sl_aiColor4D_Sm__Sg__Insert(arg1,arg2,(aiColor4D *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  std::vector< aiColor4D * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiColor4D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiColor4D_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiColor4D_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiColor4D_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiColor4D **arg1 = 0 ;
  int arg2 ;
  aiColor4D *temp1 = 0 ;
  std::vector< aiColor4D * > *result = 0 ;
  
  temp1 = (aiColor4D *)jarg1;
  arg1 = (aiColor4D **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiColor4D * > *)std_vector_Sl_aiColor4D_Sm__Sg__Repeat((aiColor4D *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  std_vector_Sl_aiColor4D_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiColor4D_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  int arg2 ;
  std::vector< aiColor4D * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiColor4D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiColor4D_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4DVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  aiColor4D **arg2 = 0 ;
  aiColor4D *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  temp2 = (aiColor4D *)jarg2;
  arg2 = (aiColor4D **)&temp2; 
  result = (bool)std_vector_Sl_aiColor4D_Sm__Sg__Contains(arg1,(aiColor4D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiColor4DVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  aiColor4D **arg2 = 0 ;
  aiColor4D *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  temp2 = (aiColor4D *)jarg2;
  arg2 = (aiColor4D **)&temp2; 
  result = (int)std_vector_Sl_aiColor4D_Sm__Sg__IndexOf(arg1,(aiColor4D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiColor4DVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  aiColor4D **arg2 = 0 ;
  aiColor4D *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  temp2 = (aiColor4D *)jarg2;
  arg2 = (aiColor4D **)&temp2; 
  result = (int)std_vector_Sl_aiColor4D_Sm__Sg__LastIndexOf(arg1,(aiColor4D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4DVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  aiColor4D **arg2 = 0 ;
  aiColor4D *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  temp2 = (aiColor4D *)jarg2;
  arg2 = (aiColor4D **)&temp2; 
  result = (bool)std_vector_Sl_aiColor4D_Sm__Sg__Remove(arg1,(aiColor4D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiColor4DVector(void * jarg1) {
  std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ;
  
  arg1 = (std::vector< aiColor4D * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_Clear(void * jarg1) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  aiFace **arg2 = 0 ;
  aiFace *temp2 = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  temp2 = (aiFace *)jarg2;
  arg2 = (aiFace **)&temp2; 
  (arg1)->push_back((aiFace *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiFaceVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  std::vector< aiFace * >::size_type result;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  result = ((std::vector< aiFace * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiFaceVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  std::vector< aiFace * >::size_type result;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  result = ((std::vector< aiFace * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  std::vector< aiFace * >::size_type arg2 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (std::vector< aiFace * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiFaceVector__SWIG_0() {
  void * jresult ;
  std::vector< aiFace * > *result = 0 ;
  
  result = (std::vector< aiFace * > *)new std::vector< aiFace * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiFaceVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiFace * > *arg1 = 0 ;
  std::vector< aiFace * > *result = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiFace * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiFace * > *)new std::vector< aiFace * >((std::vector< aiFace * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiFaceVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiFace * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiFace * > *)new_std_vector_Sl_aiFace_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiFaceVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  aiFace *result = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiFace *)std_vector_Sl_aiFace_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiFaceVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  aiFace **result = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiFace **) &std_vector_Sl_aiFace_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  aiFace **arg3 = 0 ;
  aiFace *temp3 = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiFace *)jarg3;
  arg3 = (aiFace **)&temp3; 
  try {
    std_vector_Sl_aiFace_Sm__Sg__setitem(arg1,arg2,(aiFace *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  std::vector< aiFace * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (std::vector< aiFace * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiFace * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiFace_Sm__Sg__AddRange(arg1,(std::vector< aiFace * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiFaceVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiFace * > *result = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiFace * > *)std_vector_Sl_aiFace_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  aiFace **arg3 = 0 ;
  aiFace *temp3 = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiFace *)jarg3;
  arg3 = (aiFace **)&temp3; 
  try {
    std_vector_Sl_aiFace_Sm__Sg__Insert(arg1,arg2,(aiFace *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  std::vector< aiFace * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiFace * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiFace * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiFace_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiFace * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiFace_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiFace_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiFaceVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiFace **arg1 = 0 ;
  int arg2 ;
  aiFace *temp1 = 0 ;
  std::vector< aiFace * > *result = 0 ;
  
  temp1 = (aiFace *)jarg1;
  arg1 = (aiFace **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiFace * > *)std_vector_Sl_aiFace_Sm__Sg__Repeat((aiFace *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  std_vector_Sl_aiFace_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiFace_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiFaceVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  int arg2 ;
  std::vector< aiFace * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiFace * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiFace * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiFace_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiFace * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiFaceVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  aiFace **arg2 = 0 ;
  aiFace *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  temp2 = (aiFace *)jarg2;
  arg2 = (aiFace **)&temp2; 
  result = (bool)std_vector_Sl_aiFace_Sm__Sg__Contains(arg1,(aiFace *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiFaceVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  aiFace **arg2 = 0 ;
  aiFace *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  temp2 = (aiFace *)jarg2;
  arg2 = (aiFace **)&temp2; 
  result = (int)std_vector_Sl_aiFace_Sm__Sg__IndexOf(arg1,(aiFace *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiFaceVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  aiFace **arg2 = 0 ;
  aiFace *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  temp2 = (aiFace *)jarg2;
  arg2 = (aiFace **)&temp2; 
  result = (int)std_vector_Sl_aiFace_Sm__Sg__LastIndexOf(arg1,(aiFace *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiFaceVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  aiFace **arg2 = 0 ;
  aiFace *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  temp2 = (aiFace *)jarg2;
  arg2 = (aiFace **)&temp2; 
  result = (bool)std_vector_Sl_aiFace_Sm__Sg__Remove(arg1,(aiFace *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiFaceVector(void * jarg1) {
  std::vector< aiFace * > *arg1 = (std::vector< aiFace * > *) 0 ;
  
  arg1 = (std::vector< aiFace * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_Clear(void * jarg1) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  aiLight **arg2 = 0 ;
  aiLight *temp2 = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  temp2 = (aiLight *)jarg2;
  arg2 = (aiLight **)&temp2; 
  (arg1)->push_back((aiLight *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiLightVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  std::vector< aiLight * >::size_type result;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  result = ((std::vector< aiLight * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiLightVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  std::vector< aiLight * >::size_type result;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  result = ((std::vector< aiLight * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  std::vector< aiLight * >::size_type arg2 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (std::vector< aiLight * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiLightVector__SWIG_0() {
  void * jresult ;
  std::vector< aiLight * > *result = 0 ;
  
  result = (std::vector< aiLight * > *)new std::vector< aiLight * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiLightVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiLight * > *arg1 = 0 ;
  std::vector< aiLight * > *result = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiLight * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiLight * > *)new std::vector< aiLight * >((std::vector< aiLight * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiLightVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiLight * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiLight * > *)new_std_vector_Sl_aiLight_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLightVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  aiLight *result = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiLight *)std_vector_Sl_aiLight_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLightVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  aiLight **result = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiLight **) &std_vector_Sl_aiLight_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  aiLight **arg3 = 0 ;
  aiLight *temp3 = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiLight *)jarg3;
  arg3 = (aiLight **)&temp3; 
  try {
    std_vector_Sl_aiLight_Sm__Sg__setitem(arg1,arg2,(aiLight *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  std::vector< aiLight * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (std::vector< aiLight * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiLight * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiLight_Sm__Sg__AddRange(arg1,(std::vector< aiLight * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLightVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiLight * > *result = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiLight * > *)std_vector_Sl_aiLight_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  aiLight **arg3 = 0 ;
  aiLight *temp3 = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiLight *)jarg3;
  arg3 = (aiLight **)&temp3; 
  try {
    std_vector_Sl_aiLight_Sm__Sg__Insert(arg1,arg2,(aiLight *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  std::vector< aiLight * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiLight * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiLight * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiLight_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiLight * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiLight_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiLight_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiLightVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiLight **arg1 = 0 ;
  int arg2 ;
  aiLight *temp1 = 0 ;
  std::vector< aiLight * > *result = 0 ;
  
  temp1 = (aiLight *)jarg1;
  arg1 = (aiLight **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiLight * > *)std_vector_Sl_aiLight_Sm__Sg__Repeat((aiLight *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  std_vector_Sl_aiLight_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiLight_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiLightVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  int arg2 ;
  std::vector< aiLight * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiLight * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiLight * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiLight_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiLight * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiLightVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  aiLight **arg2 = 0 ;
  aiLight *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  temp2 = (aiLight *)jarg2;
  arg2 = (aiLight **)&temp2; 
  result = (bool)std_vector_Sl_aiLight_Sm__Sg__Contains(arg1,(aiLight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiLightVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  aiLight **arg2 = 0 ;
  aiLight *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  temp2 = (aiLight *)jarg2;
  arg2 = (aiLight **)&temp2; 
  result = (int)std_vector_Sl_aiLight_Sm__Sg__IndexOf(arg1,(aiLight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiLightVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  aiLight **arg2 = 0 ;
  aiLight *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  temp2 = (aiLight *)jarg2;
  arg2 = (aiLight **)&temp2; 
  result = (int)std_vector_Sl_aiLight_Sm__Sg__LastIndexOf(arg1,(aiLight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiLightVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  aiLight **arg2 = 0 ;
  aiLight *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  temp2 = (aiLight *)jarg2;
  arg2 = (aiLight **)&temp2; 
  result = (bool)std_vector_Sl_aiLight_Sm__Sg__Remove(arg1,(aiLight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiLightVector(void * jarg1) {
  std::vector< aiLight * > *arg1 = (std::vector< aiLight * > *) 0 ;
  
  arg1 = (std::vector< aiLight * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_Clear(void * jarg1) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  aiMaterial **arg2 = 0 ;
  aiMaterial *temp2 = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  temp2 = (aiMaterial *)jarg2;
  arg2 = (aiMaterial **)&temp2; 
  (arg1)->push_back((aiMaterial *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMaterialVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  std::vector< aiMaterial * >::size_type result;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  result = ((std::vector< aiMaterial * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMaterialVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  std::vector< aiMaterial * >::size_type result;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  result = ((std::vector< aiMaterial * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  std::vector< aiMaterial * >::size_type arg2 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (std::vector< aiMaterial * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMaterialVector__SWIG_0() {
  void * jresult ;
  std::vector< aiMaterial * > *result = 0 ;
  
  result = (std::vector< aiMaterial * > *)new std::vector< aiMaterial * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMaterialVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiMaterial * > *arg1 = 0 ;
  std::vector< aiMaterial * > *result = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMaterial * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiMaterial * > *)new std::vector< aiMaterial * >((std::vector< aiMaterial * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMaterialVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiMaterial * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiMaterial * > *)new_std_vector_Sl_aiMaterial_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMaterialVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  aiMaterial *result = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMaterial *)std_vector_Sl_aiMaterial_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMaterialVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  aiMaterial **result = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMaterial **) &std_vector_Sl_aiMaterial_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  aiMaterial **arg3 = 0 ;
  aiMaterial *temp3 = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMaterial *)jarg3;
  arg3 = (aiMaterial **)&temp3; 
  try {
    std_vector_Sl_aiMaterial_Sm__Sg__setitem(arg1,arg2,(aiMaterial *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  std::vector< aiMaterial * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (std::vector< aiMaterial * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMaterial * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiMaterial_Sm__Sg__AddRange(arg1,(std::vector< aiMaterial * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMaterialVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiMaterial * > *result = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiMaterial * > *)std_vector_Sl_aiMaterial_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  aiMaterial **arg3 = 0 ;
  aiMaterial *temp3 = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMaterial *)jarg3;
  arg3 = (aiMaterial **)&temp3; 
  try {
    std_vector_Sl_aiMaterial_Sm__Sg__Insert(arg1,arg2,(aiMaterial *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  std::vector< aiMaterial * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMaterial * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMaterial * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMaterial_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiMaterial * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiMaterial_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMaterial_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMaterialVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiMaterial **arg1 = 0 ;
  int arg2 ;
  aiMaterial *temp1 = 0 ;
  std::vector< aiMaterial * > *result = 0 ;
  
  temp1 = (aiMaterial *)jarg1;
  arg1 = (aiMaterial **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiMaterial * > *)std_vector_Sl_aiMaterial_Sm__Sg__Repeat((aiMaterial *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  std_vector_Sl_aiMaterial_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMaterial_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  int arg2 ;
  std::vector< aiMaterial * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMaterial * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMaterial * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMaterial_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiMaterial * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterialVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  aiMaterial **arg2 = 0 ;
  aiMaterial *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  temp2 = (aiMaterial *)jarg2;
  arg2 = (aiMaterial **)&temp2; 
  result = (bool)std_vector_Sl_aiMaterial_Sm__Sg__Contains(arg1,(aiMaterial *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterialVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  aiMaterial **arg2 = 0 ;
  aiMaterial *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  temp2 = (aiMaterial *)jarg2;
  arg2 = (aiMaterial **)&temp2; 
  result = (int)std_vector_Sl_aiMaterial_Sm__Sg__IndexOf(arg1,(aiMaterial *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterialVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  aiMaterial **arg2 = 0 ;
  aiMaterial *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  temp2 = (aiMaterial *)jarg2;
  arg2 = (aiMaterial **)&temp2; 
  result = (int)std_vector_Sl_aiMaterial_Sm__Sg__LastIndexOf(arg1,(aiMaterial *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterialVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  aiMaterial **arg2 = 0 ;
  aiMaterial *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  temp2 = (aiMaterial *)jarg2;
  arg2 = (aiMaterial **)&temp2; 
  result = (bool)std_vector_Sl_aiMaterial_Sm__Sg__Remove(arg1,(aiMaterial *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMaterialVector(void * jarg1) {
  std::vector< aiMaterial * > *arg1 = (std::vector< aiMaterial * > *) 0 ;
  
  arg1 = (std::vector< aiMaterial * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_Clear(void * jarg1) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  aiMeshAnim **arg2 = 0 ;
  aiMeshAnim *temp2 = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  temp2 = (aiMeshAnim *)jarg2;
  arg2 = (aiMeshAnim **)&temp2; 
  (arg1)->push_back((aiMeshAnim *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMeshAnimVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  std::vector< aiMeshAnim * >::size_type result;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  result = ((std::vector< aiMeshAnim * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMeshAnimVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  std::vector< aiMeshAnim * >::size_type result;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  result = ((std::vector< aiMeshAnim * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  std::vector< aiMeshAnim * >::size_type arg2 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (std::vector< aiMeshAnim * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshAnimVector__SWIG_0() {
  void * jresult ;
  std::vector< aiMeshAnim * > *result = 0 ;
  
  result = (std::vector< aiMeshAnim * > *)new std::vector< aiMeshAnim * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshAnimVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiMeshAnim * > *arg1 = 0 ;
  std::vector< aiMeshAnim * > *result = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshAnim * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiMeshAnim * > *)new std::vector< aiMeshAnim * >((std::vector< aiMeshAnim * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshAnimVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiMeshAnim * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiMeshAnim * > *)new_std_vector_Sl_aiMeshAnim_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshAnimVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  aiMeshAnim *result = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMeshAnim *)std_vector_Sl_aiMeshAnim_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshAnimVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  aiMeshAnim **result = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMeshAnim **) &std_vector_Sl_aiMeshAnim_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  aiMeshAnim **arg3 = 0 ;
  aiMeshAnim *temp3 = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMeshAnim *)jarg3;
  arg3 = (aiMeshAnim **)&temp3; 
  try {
    std_vector_Sl_aiMeshAnim_Sm__Sg__setitem(arg1,arg2,(aiMeshAnim *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  std::vector< aiMeshAnim * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (std::vector< aiMeshAnim * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshAnim * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiMeshAnim_Sm__Sg__AddRange(arg1,(std::vector< aiMeshAnim * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshAnimVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiMeshAnim * > *result = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiMeshAnim * > *)std_vector_Sl_aiMeshAnim_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  aiMeshAnim **arg3 = 0 ;
  aiMeshAnim *temp3 = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMeshAnim *)jarg3;
  arg3 = (aiMeshAnim **)&temp3; 
  try {
    std_vector_Sl_aiMeshAnim_Sm__Sg__Insert(arg1,arg2,(aiMeshAnim *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  std::vector< aiMeshAnim * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMeshAnim * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshAnim * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMeshAnim_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiMeshAnim * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiMeshAnim_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMeshAnim_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshAnimVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiMeshAnim **arg1 = 0 ;
  int arg2 ;
  aiMeshAnim *temp1 = 0 ;
  std::vector< aiMeshAnim * > *result = 0 ;
  
  temp1 = (aiMeshAnim *)jarg1;
  arg1 = (aiMeshAnim **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiMeshAnim * > *)std_vector_Sl_aiMeshAnim_Sm__Sg__Repeat((aiMeshAnim *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  std_vector_Sl_aiMeshAnim_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMeshAnim_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshAnimVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  int arg2 ;
  std::vector< aiMeshAnim * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMeshAnim * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshAnim * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMeshAnim_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiMeshAnim * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshAnimVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  aiMeshAnim **arg2 = 0 ;
  aiMeshAnim *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  temp2 = (aiMeshAnim *)jarg2;
  arg2 = (aiMeshAnim **)&temp2; 
  result = (bool)std_vector_Sl_aiMeshAnim_Sm__Sg__Contains(arg1,(aiMeshAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMeshAnimVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  aiMeshAnim **arg2 = 0 ;
  aiMeshAnim *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  temp2 = (aiMeshAnim *)jarg2;
  arg2 = (aiMeshAnim **)&temp2; 
  result = (int)std_vector_Sl_aiMeshAnim_Sm__Sg__IndexOf(arg1,(aiMeshAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMeshAnimVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  aiMeshAnim **arg2 = 0 ;
  aiMeshAnim *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  temp2 = (aiMeshAnim *)jarg2;
  arg2 = (aiMeshAnim **)&temp2; 
  result = (int)std_vector_Sl_aiMeshAnim_Sm__Sg__LastIndexOf(arg1,(aiMeshAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshAnimVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  aiMeshAnim **arg2 = 0 ;
  aiMeshAnim *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  temp2 = (aiMeshAnim *)jarg2;
  arg2 = (aiMeshAnim **)&temp2; 
  result = (bool)std_vector_Sl_aiMeshAnim_Sm__Sg__Remove(arg1,(aiMeshAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMeshAnimVector(void * jarg1) {
  std::vector< aiMeshAnim * > *arg1 = (std::vector< aiMeshAnim * > *) 0 ;
  
  arg1 = (std::vector< aiMeshAnim * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_Clear(void * jarg1) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  aiMeshKey **arg2 = 0 ;
  aiMeshKey *temp2 = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  temp2 = (aiMeshKey *)jarg2;
  arg2 = (aiMeshKey **)&temp2; 
  (arg1)->push_back((aiMeshKey *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMeshKeyVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  std::vector< aiMeshKey * >::size_type result;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  result = ((std::vector< aiMeshKey * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMeshKeyVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  std::vector< aiMeshKey * >::size_type result;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  result = ((std::vector< aiMeshKey * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  std::vector< aiMeshKey * >::size_type arg2 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (std::vector< aiMeshKey * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshKeyVector__SWIG_0() {
  void * jresult ;
  std::vector< aiMeshKey * > *result = 0 ;
  
  result = (std::vector< aiMeshKey * > *)new std::vector< aiMeshKey * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshKeyVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiMeshKey * > *arg1 = 0 ;
  std::vector< aiMeshKey * > *result = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshKey * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiMeshKey * > *)new std::vector< aiMeshKey * >((std::vector< aiMeshKey * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshKeyVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiMeshKey * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiMeshKey * > *)new_std_vector_Sl_aiMeshKey_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshKeyVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  aiMeshKey *result = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMeshKey *)std_vector_Sl_aiMeshKey_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshKeyVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  aiMeshKey **result = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMeshKey **) &std_vector_Sl_aiMeshKey_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  aiMeshKey **arg3 = 0 ;
  aiMeshKey *temp3 = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMeshKey *)jarg3;
  arg3 = (aiMeshKey **)&temp3; 
  try {
    std_vector_Sl_aiMeshKey_Sm__Sg__setitem(arg1,arg2,(aiMeshKey *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  std::vector< aiMeshKey * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (std::vector< aiMeshKey * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshKey * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiMeshKey_Sm__Sg__AddRange(arg1,(std::vector< aiMeshKey * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshKeyVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiMeshKey * > *result = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiMeshKey * > *)std_vector_Sl_aiMeshKey_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  aiMeshKey **arg3 = 0 ;
  aiMeshKey *temp3 = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMeshKey *)jarg3;
  arg3 = (aiMeshKey **)&temp3; 
  try {
    std_vector_Sl_aiMeshKey_Sm__Sg__Insert(arg1,arg2,(aiMeshKey *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  std::vector< aiMeshKey * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMeshKey * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshKey * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMeshKey_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiMeshKey * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiMeshKey_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMeshKey_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshKeyVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiMeshKey **arg1 = 0 ;
  int arg2 ;
  aiMeshKey *temp1 = 0 ;
  std::vector< aiMeshKey * > *result = 0 ;
  
  temp1 = (aiMeshKey *)jarg1;
  arg1 = (aiMeshKey **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiMeshKey * > *)std_vector_Sl_aiMeshKey_Sm__Sg__Repeat((aiMeshKey *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  std_vector_Sl_aiMeshKey_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMeshKey_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshKeyVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  int arg2 ;
  std::vector< aiMeshKey * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMeshKey * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMeshKey * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMeshKey_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiMeshKey * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKeyVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  aiMeshKey **arg2 = 0 ;
  aiMeshKey *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  temp2 = (aiMeshKey *)jarg2;
  arg2 = (aiMeshKey **)&temp2; 
  result = (bool)std_vector_Sl_aiMeshKey_Sm__Sg__Contains(arg1,(aiMeshKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMeshKeyVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  aiMeshKey **arg2 = 0 ;
  aiMeshKey *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  temp2 = (aiMeshKey *)jarg2;
  arg2 = (aiMeshKey **)&temp2; 
  result = (int)std_vector_Sl_aiMeshKey_Sm__Sg__IndexOf(arg1,(aiMeshKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMeshKeyVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  aiMeshKey **arg2 = 0 ;
  aiMeshKey *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  temp2 = (aiMeshKey *)jarg2;
  arg2 = (aiMeshKey **)&temp2; 
  result = (int)std_vector_Sl_aiMeshKey_Sm__Sg__LastIndexOf(arg1,(aiMeshKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshKeyVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  aiMeshKey **arg2 = 0 ;
  aiMeshKey *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  temp2 = (aiMeshKey *)jarg2;
  arg2 = (aiMeshKey **)&temp2; 
  result = (bool)std_vector_Sl_aiMeshKey_Sm__Sg__Remove(arg1,(aiMeshKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMeshKeyVector(void * jarg1) {
  std::vector< aiMeshKey * > *arg1 = (std::vector< aiMeshKey * > *) 0 ;
  
  arg1 = (std::vector< aiMeshKey * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_Clear(void * jarg1) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  aiMesh **arg2 = 0 ;
  aiMesh *temp2 = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  temp2 = (aiMesh *)jarg2;
  arg2 = (aiMesh **)&temp2; 
  (arg1)->push_back((aiMesh *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMeshVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  std::vector< aiMesh * >::size_type result;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  result = ((std::vector< aiMesh * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiMeshVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  std::vector< aiMesh * >::size_type result;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  result = ((std::vector< aiMesh * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  std::vector< aiMesh * >::size_type arg2 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (std::vector< aiMesh * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshVector__SWIG_0() {
  void * jresult ;
  std::vector< aiMesh * > *result = 0 ;
  
  result = (std::vector< aiMesh * > *)new std::vector< aiMesh * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiMesh * > *arg1 = 0 ;
  std::vector< aiMesh * > *result = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMesh * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiMesh * > *)new std::vector< aiMesh * >((std::vector< aiMesh * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMeshVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiMesh * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiMesh * > *)new_std_vector_Sl_aiMesh_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  aiMesh *result = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMesh *)std_vector_Sl_aiMesh_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  aiMesh **result = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiMesh **) &std_vector_Sl_aiMesh_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  aiMesh **arg3 = 0 ;
  aiMesh *temp3 = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMesh *)jarg3;
  arg3 = (aiMesh **)&temp3; 
  try {
    std_vector_Sl_aiMesh_Sm__Sg__setitem(arg1,arg2,(aiMesh *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  std::vector< aiMesh * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (std::vector< aiMesh * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMesh * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiMesh_Sm__Sg__AddRange(arg1,(std::vector< aiMesh * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiMesh * > *result = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiMesh * > *)std_vector_Sl_aiMesh_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  aiMesh **arg3 = 0 ;
  aiMesh *temp3 = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiMesh *)jarg3;
  arg3 = (aiMesh **)&temp3; 
  try {
    std_vector_Sl_aiMesh_Sm__Sg__Insert(arg1,arg2,(aiMesh *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  std::vector< aiMesh * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMesh * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMesh * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMesh_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiMesh * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiMesh_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMesh_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiMeshVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiMesh **arg1 = 0 ;
  int arg2 ;
  aiMesh *temp1 = 0 ;
  std::vector< aiMesh * > *result = 0 ;
  
  temp1 = (aiMesh *)jarg1;
  arg1 = (aiMesh **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiMesh * > *)std_vector_Sl_aiMesh_Sm__Sg__Repeat((aiMesh *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  std_vector_Sl_aiMesh_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiMesh_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiMeshVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  int arg2 ;
  std::vector< aiMesh * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiMesh * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiMesh * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiMesh_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiMesh * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  aiMesh **arg2 = 0 ;
  aiMesh *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  temp2 = (aiMesh *)jarg2;
  arg2 = (aiMesh **)&temp2; 
  result = (bool)std_vector_Sl_aiMesh_Sm__Sg__Contains(arg1,(aiMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMeshVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  aiMesh **arg2 = 0 ;
  aiMesh *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  temp2 = (aiMesh *)jarg2;
  arg2 = (aiMesh **)&temp2; 
  result = (int)std_vector_Sl_aiMesh_Sm__Sg__IndexOf(arg1,(aiMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiMeshVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  aiMesh **arg2 = 0 ;
  aiMesh *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  temp2 = (aiMesh *)jarg2;
  arg2 = (aiMesh **)&temp2; 
  result = (int)std_vector_Sl_aiMesh_Sm__Sg__LastIndexOf(arg1,(aiMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMeshVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  aiMesh **arg2 = 0 ;
  aiMesh *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  temp2 = (aiMesh *)jarg2;
  arg2 = (aiMesh **)&temp2; 
  result = (bool)std_vector_Sl_aiMesh_Sm__Sg__Remove(arg1,(aiMesh *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMeshVector(void * jarg1) {
  std::vector< aiMesh * > *arg1 = (std::vector< aiMesh * > *) 0 ;
  
  arg1 = (std::vector< aiMesh * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_Clear(void * jarg1) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  aiNode **arg2 = 0 ;
  aiNode *temp2 = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  temp2 = (aiNode *)jarg2;
  arg2 = (aiNode **)&temp2; 
  (arg1)->push_back((aiNode *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiNodeVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  std::vector< aiNode * >::size_type result;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  result = ((std::vector< aiNode * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiNodeVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  std::vector< aiNode * >::size_type result;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  result = ((std::vector< aiNode * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  std::vector< aiNode * >::size_type arg2 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (std::vector< aiNode * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeVector__SWIG_0() {
  void * jresult ;
  std::vector< aiNode * > *result = 0 ;
  
  result = (std::vector< aiNode * > *)new std::vector< aiNode * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiNode * > *arg1 = 0 ;
  std::vector< aiNode * > *result = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNode * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiNode * > *)new std::vector< aiNode * >((std::vector< aiNode * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiNode * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiNode * > *)new_std_vector_Sl_aiNode_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  aiNode *result = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiNode *)std_vector_Sl_aiNode_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  aiNode **result = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiNode **) &std_vector_Sl_aiNode_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  aiNode **arg3 = 0 ;
  aiNode *temp3 = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiNode *)jarg3;
  arg3 = (aiNode **)&temp3; 
  try {
    std_vector_Sl_aiNode_Sm__Sg__setitem(arg1,arg2,(aiNode *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  std::vector< aiNode * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (std::vector< aiNode * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNode * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiNode_Sm__Sg__AddRange(arg1,(std::vector< aiNode * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiNode * > *result = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiNode * > *)std_vector_Sl_aiNode_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  aiNode **arg3 = 0 ;
  aiNode *temp3 = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiNode *)jarg3;
  arg3 = (aiNode **)&temp3; 
  try {
    std_vector_Sl_aiNode_Sm__Sg__Insert(arg1,arg2,(aiNode *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  std::vector< aiNode * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiNode * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNode * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiNode_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiNode * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiNode_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiNode_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiNode **arg1 = 0 ;
  int arg2 ;
  aiNode *temp1 = 0 ;
  std::vector< aiNode * > *result = 0 ;
  
  temp1 = (aiNode *)jarg1;
  arg1 = (aiNode **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiNode * > *)std_vector_Sl_aiNode_Sm__Sg__Repeat((aiNode *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  std_vector_Sl_aiNode_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiNode_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  int arg2 ;
  std::vector< aiNode * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiNode * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNode * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiNode_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiNode * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  aiNode **arg2 = 0 ;
  aiNode *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  temp2 = (aiNode *)jarg2;
  arg2 = (aiNode **)&temp2; 
  result = (bool)std_vector_Sl_aiNode_Sm__Sg__Contains(arg1,(aiNode *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiNodeVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  aiNode **arg2 = 0 ;
  aiNode *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  temp2 = (aiNode *)jarg2;
  arg2 = (aiNode **)&temp2; 
  result = (int)std_vector_Sl_aiNode_Sm__Sg__IndexOf(arg1,(aiNode *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiNodeVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  aiNode **arg2 = 0 ;
  aiNode *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  temp2 = (aiNode *)jarg2;
  arg2 = (aiNode **)&temp2; 
  result = (int)std_vector_Sl_aiNode_Sm__Sg__LastIndexOf(arg1,(aiNode *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  aiNode **arg2 = 0 ;
  aiNode *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  temp2 = (aiNode *)jarg2;
  arg2 = (aiNode **)&temp2; 
  result = (bool)std_vector_Sl_aiNode_Sm__Sg__Remove(arg1,(aiNode *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiNodeVector(void * jarg1) {
  std::vector< aiNode * > *arg1 = (std::vector< aiNode * > *) 0 ;
  
  arg1 = (std::vector< aiNode * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_Clear(void * jarg1) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  aiNodeAnim **arg2 = 0 ;
  aiNodeAnim *temp2 = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  temp2 = (aiNodeAnim *)jarg2;
  arg2 = (aiNodeAnim **)&temp2; 
  (arg1)->push_back((aiNodeAnim *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiNodeAnimVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  std::vector< aiNodeAnim * >::size_type result;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  result = ((std::vector< aiNodeAnim * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiNodeAnimVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  std::vector< aiNodeAnim * >::size_type result;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  result = ((std::vector< aiNodeAnim * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  std::vector< aiNodeAnim * >::size_type arg2 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (std::vector< aiNodeAnim * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeAnimVector__SWIG_0() {
  void * jresult ;
  std::vector< aiNodeAnim * > *result = 0 ;
  
  result = (std::vector< aiNodeAnim * > *)new std::vector< aiNodeAnim * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeAnimVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiNodeAnim * > *arg1 = 0 ;
  std::vector< aiNodeAnim * > *result = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNodeAnim * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiNodeAnim * > *)new std::vector< aiNodeAnim * >((std::vector< aiNodeAnim * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiNodeAnimVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiNodeAnim * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiNodeAnim * > *)new_std_vector_Sl_aiNodeAnim_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnimVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  aiNodeAnim *result = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiNodeAnim *)std_vector_Sl_aiNodeAnim_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnimVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  aiNodeAnim **result = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiNodeAnim **) &std_vector_Sl_aiNodeAnim_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  aiNodeAnim **arg3 = 0 ;
  aiNodeAnim *temp3 = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiNodeAnim *)jarg3;
  arg3 = (aiNodeAnim **)&temp3; 
  try {
    std_vector_Sl_aiNodeAnim_Sm__Sg__setitem(arg1,arg2,(aiNodeAnim *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  std::vector< aiNodeAnim * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (std::vector< aiNodeAnim * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNodeAnim * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiNodeAnim_Sm__Sg__AddRange(arg1,(std::vector< aiNodeAnim * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnimVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiNodeAnim * > *result = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiNodeAnim * > *)std_vector_Sl_aiNodeAnim_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  aiNodeAnim **arg3 = 0 ;
  aiNodeAnim *temp3 = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiNodeAnim *)jarg3;
  arg3 = (aiNodeAnim **)&temp3; 
  try {
    std_vector_Sl_aiNodeAnim_Sm__Sg__Insert(arg1,arg2,(aiNodeAnim *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  std::vector< aiNodeAnim * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiNodeAnim * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNodeAnim * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiNodeAnim_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiNodeAnim * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiNodeAnim_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiNodeAnim_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiNodeAnimVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiNodeAnim **arg1 = 0 ;
  int arg2 ;
  aiNodeAnim *temp1 = 0 ;
  std::vector< aiNodeAnim * > *result = 0 ;
  
  temp1 = (aiNodeAnim *)jarg1;
  arg1 = (aiNodeAnim **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiNodeAnim * > *)std_vector_Sl_aiNodeAnim_Sm__Sg__Repeat((aiNodeAnim *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  std_vector_Sl_aiNodeAnim_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiNodeAnim_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiNodeAnimVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  int arg2 ;
  std::vector< aiNodeAnim * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiNodeAnim * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiNodeAnim * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiNodeAnim_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiNodeAnim * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeAnimVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  aiNodeAnim **arg2 = 0 ;
  aiNodeAnim *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  temp2 = (aiNodeAnim *)jarg2;
  arg2 = (aiNodeAnim **)&temp2; 
  result = (bool)std_vector_Sl_aiNodeAnim_Sm__Sg__Contains(arg1,(aiNodeAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiNodeAnimVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  aiNodeAnim **arg2 = 0 ;
  aiNodeAnim *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  temp2 = (aiNodeAnim *)jarg2;
  arg2 = (aiNodeAnim **)&temp2; 
  result = (int)std_vector_Sl_aiNodeAnim_Sm__Sg__IndexOf(arg1,(aiNodeAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiNodeAnimVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  aiNodeAnim **arg2 = 0 ;
  aiNodeAnim *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  temp2 = (aiNodeAnim *)jarg2;
  arg2 = (aiNodeAnim **)&temp2; 
  result = (int)std_vector_Sl_aiNodeAnim_Sm__Sg__LastIndexOf(arg1,(aiNodeAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiNodeAnimVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  aiNodeAnim **arg2 = 0 ;
  aiNodeAnim *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  temp2 = (aiNodeAnim *)jarg2;
  arg2 = (aiNodeAnim **)&temp2; 
  result = (bool)std_vector_Sl_aiNodeAnim_Sm__Sg__Remove(arg1,(aiNodeAnim *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiNodeAnimVector(void * jarg1) {
  std::vector< aiNodeAnim * > *arg1 = (std::vector< aiNodeAnim * > *) 0 ;
  
  arg1 = (std::vector< aiNodeAnim * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_Clear(void * jarg1) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  aiQuatKey **arg2 = 0 ;
  aiQuatKey *temp2 = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  temp2 = (aiQuatKey *)jarg2;
  arg2 = (aiQuatKey **)&temp2; 
  (arg1)->push_back((aiQuatKey *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiQuatKeyVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  std::vector< aiQuatKey * >::size_type result;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  result = ((std::vector< aiQuatKey * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiQuatKeyVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  std::vector< aiQuatKey * >::size_type result;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  result = ((std::vector< aiQuatKey * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  std::vector< aiQuatKey * >::size_type arg2 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (std::vector< aiQuatKey * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuatKeyVector__SWIG_0() {
  void * jresult ;
  std::vector< aiQuatKey * > *result = 0 ;
  
  result = (std::vector< aiQuatKey * > *)new std::vector< aiQuatKey * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuatKeyVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiQuatKey * > *arg1 = 0 ;
  std::vector< aiQuatKey * > *result = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiQuatKey * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiQuatKey * > *)new std::vector< aiQuatKey * >((std::vector< aiQuatKey * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuatKeyVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiQuatKey * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiQuatKey * > *)new_std_vector_Sl_aiQuatKey_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuatKeyVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  aiQuatKey *result = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiQuatKey *)std_vector_Sl_aiQuatKey_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuatKeyVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  aiQuatKey **result = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiQuatKey **) &std_vector_Sl_aiQuatKey_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  aiQuatKey **arg3 = 0 ;
  aiQuatKey *temp3 = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiQuatKey *)jarg3;
  arg3 = (aiQuatKey **)&temp3; 
  try {
    std_vector_Sl_aiQuatKey_Sm__Sg__setitem(arg1,arg2,(aiQuatKey *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  std::vector< aiQuatKey * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (std::vector< aiQuatKey * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiQuatKey * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiQuatKey_Sm__Sg__AddRange(arg1,(std::vector< aiQuatKey * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuatKeyVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiQuatKey * > *result = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiQuatKey * > *)std_vector_Sl_aiQuatKey_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  aiQuatKey **arg3 = 0 ;
  aiQuatKey *temp3 = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiQuatKey *)jarg3;
  arg3 = (aiQuatKey **)&temp3; 
  try {
    std_vector_Sl_aiQuatKey_Sm__Sg__Insert(arg1,arg2,(aiQuatKey *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  std::vector< aiQuatKey * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiQuatKey * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiQuatKey * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiQuatKey_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiQuatKey * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiQuatKey_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiQuatKey_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuatKeyVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiQuatKey **arg1 = 0 ;
  int arg2 ;
  aiQuatKey *temp1 = 0 ;
  std::vector< aiQuatKey * > *result = 0 ;
  
  temp1 = (aiQuatKey *)jarg1;
  arg1 = (aiQuatKey **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiQuatKey * > *)std_vector_Sl_aiQuatKey_Sm__Sg__Repeat((aiQuatKey *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  std_vector_Sl_aiQuatKey_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiQuatKey_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiQuatKeyVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  int arg2 ;
  std::vector< aiQuatKey * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiQuatKey * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiQuatKey * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiQuatKey_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiQuatKey * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuatKeyVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  aiQuatKey **arg2 = 0 ;
  aiQuatKey *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  temp2 = (aiQuatKey *)jarg2;
  arg2 = (aiQuatKey **)&temp2; 
  result = (bool)std_vector_Sl_aiQuatKey_Sm__Sg__Contains(arg1,(aiQuatKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiQuatKeyVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  aiQuatKey **arg2 = 0 ;
  aiQuatKey *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  temp2 = (aiQuatKey *)jarg2;
  arg2 = (aiQuatKey **)&temp2; 
  result = (int)std_vector_Sl_aiQuatKey_Sm__Sg__IndexOf(arg1,(aiQuatKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiQuatKeyVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  aiQuatKey **arg2 = 0 ;
  aiQuatKey *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  temp2 = (aiQuatKey *)jarg2;
  arg2 = (aiQuatKey **)&temp2; 
  result = (int)std_vector_Sl_aiQuatKey_Sm__Sg__LastIndexOf(arg1,(aiQuatKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuatKeyVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  aiQuatKey **arg2 = 0 ;
  aiQuatKey *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  temp2 = (aiQuatKey *)jarg2;
  arg2 = (aiQuatKey **)&temp2; 
  result = (bool)std_vector_Sl_aiQuatKey_Sm__Sg__Remove(arg1,(aiQuatKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiQuatKeyVector(void * jarg1) {
  std::vector< aiQuatKey * > *arg1 = (std::vector< aiQuatKey * > *) 0 ;
  
  arg1 = (std::vector< aiQuatKey * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_Clear(void * jarg1) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  aiTexture **arg2 = 0 ;
  aiTexture *temp2 = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  temp2 = (aiTexture *)jarg2;
  arg2 = (aiTexture **)&temp2; 
  (arg1)->push_back((aiTexture *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiTextureVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  std::vector< aiTexture * >::size_type result;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  result = ((std::vector< aiTexture * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiTextureVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  std::vector< aiTexture * >::size_type result;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  result = ((std::vector< aiTexture * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  std::vector< aiTexture * >::size_type arg2 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (std::vector< aiTexture * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiTextureVector__SWIG_0() {
  void * jresult ;
  std::vector< aiTexture * > *result = 0 ;
  
  result = (std::vector< aiTexture * > *)new std::vector< aiTexture * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiTextureVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiTexture * > *arg1 = 0 ;
  std::vector< aiTexture * > *result = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiTexture * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiTexture * > *)new std::vector< aiTexture * >((std::vector< aiTexture * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiTextureVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiTexture * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiTexture * > *)new_std_vector_Sl_aiTexture_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiTextureVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  aiTexture *result = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiTexture *)std_vector_Sl_aiTexture_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiTextureVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  aiTexture **result = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiTexture **) &std_vector_Sl_aiTexture_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  aiTexture **arg3 = 0 ;
  aiTexture *temp3 = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiTexture *)jarg3;
  arg3 = (aiTexture **)&temp3; 
  try {
    std_vector_Sl_aiTexture_Sm__Sg__setitem(arg1,arg2,(aiTexture *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  std::vector< aiTexture * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (std::vector< aiTexture * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiTexture * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiTexture_Sm__Sg__AddRange(arg1,(std::vector< aiTexture * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiTextureVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiTexture * > *result = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiTexture * > *)std_vector_Sl_aiTexture_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  aiTexture **arg3 = 0 ;
  aiTexture *temp3 = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiTexture *)jarg3;
  arg3 = (aiTexture **)&temp3; 
  try {
    std_vector_Sl_aiTexture_Sm__Sg__Insert(arg1,arg2,(aiTexture *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  std::vector< aiTexture * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiTexture * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiTexture * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiTexture_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiTexture * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiTexture_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiTexture_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiTextureVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiTexture **arg1 = 0 ;
  int arg2 ;
  aiTexture *temp1 = 0 ;
  std::vector< aiTexture * > *result = 0 ;
  
  temp1 = (aiTexture *)jarg1;
  arg1 = (aiTexture **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiTexture * > *)std_vector_Sl_aiTexture_Sm__Sg__Repeat((aiTexture *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  std_vector_Sl_aiTexture_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiTexture_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiTextureVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  int arg2 ;
  std::vector< aiTexture * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiTexture * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiTexture * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiTexture_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiTexture * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTextureVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  aiTexture **arg2 = 0 ;
  aiTexture *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  temp2 = (aiTexture *)jarg2;
  arg2 = (aiTexture **)&temp2; 
  result = (bool)std_vector_Sl_aiTexture_Sm__Sg__Contains(arg1,(aiTexture *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiTextureVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  aiTexture **arg2 = 0 ;
  aiTexture *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  temp2 = (aiTexture *)jarg2;
  arg2 = (aiTexture **)&temp2; 
  result = (int)std_vector_Sl_aiTexture_Sm__Sg__IndexOf(arg1,(aiTexture *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiTextureVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  aiTexture **arg2 = 0 ;
  aiTexture *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  temp2 = (aiTexture *)jarg2;
  arg2 = (aiTexture **)&temp2; 
  result = (int)std_vector_Sl_aiTexture_Sm__Sg__LastIndexOf(arg1,(aiTexture *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiTextureVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  aiTexture **arg2 = 0 ;
  aiTexture *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  temp2 = (aiTexture *)jarg2;
  arg2 = (aiTexture **)&temp2; 
  result = (bool)std_vector_Sl_aiTexture_Sm__Sg__Remove(arg1,(aiTexture *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiTextureVector(void * jarg1) {
  std::vector< aiTexture * > *arg1 = (std::vector< aiTexture * > *) 0 ;
  
  arg1 = (std::vector< aiTexture * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Clear(void * jarg1) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  aiVector3D **arg2 = 0 ;
  aiVector3D *temp2 = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  temp2 = (aiVector3D *)jarg2;
  arg2 = (aiVector3D **)&temp2; 
  (arg1)->push_back((aiVector3D *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  std::vector< aiVector3D * >::size_type result;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  result = ((std::vector< aiVector3D * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  std::vector< aiVector3D * >::size_type result;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  result = ((std::vector< aiVector3D * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  std::vector< aiVector3D * >::size_type arg2 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (std::vector< aiVector3D * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3DVector__SWIG_0() {
  void * jresult ;
  std::vector< aiVector3D * > *result = 0 ;
  
  result = (std::vector< aiVector3D * > *)new std::vector< aiVector3D * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3DVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiVector3D * > *arg1 = 0 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiVector3D * > *)new std::vector< aiVector3D * >((std::vector< aiVector3D * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3DVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiVector3D * > *)new_std_vector_Sl_aiVector3D_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  aiVector3D *result = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiVector3D *)std_vector_Sl_aiVector3D_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  aiVector3D **result = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiVector3D **) &std_vector_Sl_aiVector3D_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  aiVector3D **arg3 = 0 ;
  aiVector3D *temp3 = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiVector3D *)jarg3;
  arg3 = (aiVector3D **)&temp3; 
  try {
    std_vector_Sl_aiVector3D_Sm__Sg__setitem(arg1,arg2,(aiVector3D *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  std::vector< aiVector3D * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (std::vector< aiVector3D * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiVector3D_Sm__Sg__AddRange(arg1,(std::vector< aiVector3D * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiVector3D * > *)std_vector_Sl_aiVector3D_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  aiVector3D **arg3 = 0 ;
  aiVector3D *temp3 = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiVector3D *)jarg3;
  arg3 = (aiVector3D **)&temp3; 
  try {
    std_vector_Sl_aiVector3D_Sm__Sg__Insert(arg1,arg2,(aiVector3D *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  std::vector< aiVector3D * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVector3D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiVector3D_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiVector3D_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiVector3D_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiVector3D **arg1 = 0 ;
  int arg2 ;
  aiVector3D *temp1 = 0 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  temp1 = (aiVector3D *)jarg1;
  arg1 = (aiVector3D **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiVector3D * > *)std_vector_Sl_aiVector3D_Sm__Sg__Repeat((aiVector3D *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  std_vector_Sl_aiVector3D_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiVector3D_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  int arg2 ;
  std::vector< aiVector3D * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVector3D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiVector3D_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3DVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  aiVector3D **arg2 = 0 ;
  aiVector3D *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  temp2 = (aiVector3D *)jarg2;
  arg2 = (aiVector3D **)&temp2; 
  result = (bool)std_vector_Sl_aiVector3D_Sm__Sg__Contains(arg1,(aiVector3D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiVector3DVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  aiVector3D **arg2 = 0 ;
  aiVector3D *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  temp2 = (aiVector3D *)jarg2;
  arg2 = (aiVector3D **)&temp2; 
  result = (int)std_vector_Sl_aiVector3D_Sm__Sg__IndexOf(arg1,(aiVector3D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiVector3DVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  aiVector3D **arg2 = 0 ;
  aiVector3D *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  temp2 = (aiVector3D *)jarg2;
  arg2 = (aiVector3D **)&temp2; 
  result = (int)std_vector_Sl_aiVector3D_Sm__Sg__LastIndexOf(arg1,(aiVector3D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3DVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  aiVector3D **arg2 = 0 ;
  aiVector3D *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  temp2 = (aiVector3D *)jarg2;
  arg2 = (aiVector3D **)&temp2; 
  result = (bool)std_vector_Sl_aiVector3D_Sm__Sg__Remove(arg1,(aiVector3D *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector3DVector(void * jarg1) {
  std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Clear(void * jarg1) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  std::vector< aiVector3D * > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (std::vector< aiVector3D * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return ;
  } 
  (arg1)->push_back((std::vector< aiVector3D * > const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVectorVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  std::vector< std::vector< aiVector3D * > >::size_type result;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  result = ((std::vector< std::vector< aiVector3D * > > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVectorVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  std::vector< std::vector< aiVector3D * > >::size_type result;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  result = ((std::vector< std::vector< aiVector3D * > > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  std::vector< std::vector< aiVector3D * > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (std::vector< std::vector< aiVector3D * > >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3DVectorVector__SWIG_0() {
  void * jresult ;
  std::vector< std::vector< aiVector3D * > > *result = 0 ;
  
  result = (std::vector< std::vector< aiVector3D * > > *)new std::vector< std::vector< aiVector3D * > >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3DVectorVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< aiVector3D * > > *arg1 = 0 ;
  std::vector< std::vector< aiVector3D * > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiVector3D * > > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< std::vector< aiVector3D * > > *)new std::vector< std::vector< aiVector3D * > >((std::vector< std::vector< aiVector3D * > > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3DVectorVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< aiVector3D * > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< std::vector< aiVector3D * > > *)new_std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVectorVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  std::vector< aiVector3D * > result;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = new std::vector< aiVector3D * >((const std::vector< aiVector3D * > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  std::vector< aiVector3D * > *result = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiVector3D * > *) &std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  std::vector< aiVector3D * > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVector3D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__setitem(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  std::vector< std::vector< aiVector3D * > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (std::vector< std::vector< aiVector3D * > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiVector3D * > > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__AddRange(arg1,(std::vector< std::vector< aiVector3D * > > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVectorVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< aiVector3D * > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< std::vector< aiVector3D * > > *)std_vector_Sl_std_vector_Sl_aiVector3D_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  std::vector< aiVector3D * > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVector3D * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Insert(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< aiVector3D * > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< aiVector3D * > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiVector3D * > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< aiVector3D * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVectorVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVector3D * > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< aiVector3D * > > *result = 0 ;
  
  arg1 = (std::vector< aiVector3D * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::vector< aiVector3D * > > *)std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Repeat((std::vector< aiVector3D * > const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< aiVector3D * > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< aiVector3D * > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiVector3D * > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< aiVector3D * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector3DVectorVector(void * jarg1) {
  std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ;
  
  arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_Clear(void * jarg1) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  aiVectorKey **arg2 = 0 ;
  aiVectorKey *temp2 = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  temp2 = (aiVectorKey *)jarg2;
  arg2 = (aiVectorKey **)&temp2; 
  (arg1)->push_back((aiVectorKey *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVectorKeyVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  std::vector< aiVectorKey * >::size_type result;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  result = ((std::vector< aiVectorKey * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVectorKeyVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  std::vector< aiVectorKey * >::size_type result;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  result = ((std::vector< aiVectorKey * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  std::vector< aiVectorKey * >::size_type arg2 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (std::vector< aiVectorKey * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVectorKeyVector__SWIG_0() {
  void * jresult ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  result = (std::vector< aiVectorKey * > *)new std::vector< aiVectorKey * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVectorKeyVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiVectorKey * > *arg1 = 0 ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVectorKey * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiVectorKey * > *)new std::vector< aiVectorKey * >((std::vector< aiVectorKey * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVectorKeyVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiVectorKey * > *)new_std_vector_Sl_aiVectorKey_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVectorKeyVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  aiVectorKey *result = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiVectorKey *)std_vector_Sl_aiVectorKey_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVectorKeyVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  aiVectorKey **result = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiVectorKey **) &std_vector_Sl_aiVectorKey_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  aiVectorKey **arg3 = 0 ;
  aiVectorKey *temp3 = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiVectorKey *)jarg3;
  arg3 = (aiVectorKey **)&temp3; 
  try {
    std_vector_Sl_aiVectorKey_Sm__Sg__setitem(arg1,arg2,(aiVectorKey *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  std::vector< aiVectorKey * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (std::vector< aiVectorKey * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVectorKey * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiVectorKey_Sm__Sg__AddRange(arg1,(std::vector< aiVectorKey * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVectorKeyVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiVectorKey * > *)std_vector_Sl_aiVectorKey_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  aiVectorKey **arg3 = 0 ;
  aiVectorKey *temp3 = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiVectorKey *)jarg3;
  arg3 = (aiVectorKey **)&temp3; 
  try {
    std_vector_Sl_aiVectorKey_Sm__Sg__Insert(arg1,arg2,(aiVectorKey *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  std::vector< aiVectorKey * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVectorKey * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVectorKey * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiVectorKey_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiVectorKey * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiVectorKey_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiVectorKey_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVectorKeyVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiVectorKey **arg1 = 0 ;
  int arg2 ;
  aiVectorKey *temp1 = 0 ;
  std::vector< aiVectorKey * > *result = 0 ;
  
  temp1 = (aiVectorKey *)jarg1;
  arg1 = (aiVectorKey **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiVectorKey * > *)std_vector_Sl_aiVectorKey_Sm__Sg__Repeat((aiVectorKey *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  std_vector_Sl_aiVectorKey_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiVectorKey_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVectorKeyVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  int arg2 ;
  std::vector< aiVectorKey * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVectorKey * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVectorKey * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiVectorKey_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiVectorKey * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVectorKeyVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  aiVectorKey **arg2 = 0 ;
  aiVectorKey *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  temp2 = (aiVectorKey *)jarg2;
  arg2 = (aiVectorKey **)&temp2; 
  result = (bool)std_vector_Sl_aiVectorKey_Sm__Sg__Contains(arg1,(aiVectorKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiVectorKeyVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  aiVectorKey **arg2 = 0 ;
  aiVectorKey *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  temp2 = (aiVectorKey *)jarg2;
  arg2 = (aiVectorKey **)&temp2; 
  result = (int)std_vector_Sl_aiVectorKey_Sm__Sg__IndexOf(arg1,(aiVectorKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiVectorKeyVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  aiVectorKey **arg2 = 0 ;
  aiVectorKey *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  temp2 = (aiVectorKey *)jarg2;
  arg2 = (aiVectorKey **)&temp2; 
  result = (int)std_vector_Sl_aiVectorKey_Sm__Sg__LastIndexOf(arg1,(aiVectorKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVectorKeyVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  aiVectorKey **arg2 = 0 ;
  aiVectorKey *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  temp2 = (aiVectorKey *)jarg2;
  arg2 = (aiVectorKey **)&temp2; 
  result = (bool)std_vector_Sl_aiVectorKey_Sm__Sg__Remove(arg1,(aiVectorKey *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVectorKeyVector(void * jarg1) {
  std::vector< aiVectorKey * > *arg1 = (std::vector< aiVectorKey * > *) 0 ;
  
  arg1 = (std::vector< aiVectorKey * > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_Clear(void * jarg1) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_Add(void * jarg1, void * jarg2) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  aiVertexWeight **arg2 = 0 ;
  aiVertexWeight *temp2 = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  temp2 = (aiVertexWeight *)jarg2;
  arg2 = (aiVertexWeight **)&temp2; 
  (arg1)->push_back((aiVertexWeight *const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVertexWeightVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  std::vector< aiVertexWeight * >::size_type result;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  result = ((std::vector< aiVertexWeight * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVertexWeightVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  std::vector< aiVertexWeight * >::size_type result;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  result = ((std::vector< aiVertexWeight * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  std::vector< aiVertexWeight * >::size_type arg2 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (std::vector< aiVertexWeight * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVertexWeightVector__SWIG_0() {
  void * jresult ;
  std::vector< aiVertexWeight * > *result = 0 ;
  
  result = (std::vector< aiVertexWeight * > *)new std::vector< aiVertexWeight * >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVertexWeightVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< aiVertexWeight * > *arg1 = 0 ;
  std::vector< aiVertexWeight * > *result = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVertexWeight * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< aiVertexWeight * > *)new std::vector< aiVertexWeight * >((std::vector< aiVertexWeight * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVertexWeightVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< aiVertexWeight * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< aiVertexWeight * > *)new_std_vector_Sl_aiVertexWeight_Sm__Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVertexWeightVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  aiVertexWeight *result = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiVertexWeight *)std_vector_Sl_aiVertexWeight_Sm__Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVertexWeightVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  aiVertexWeight **result = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (aiVertexWeight **) &std_vector_Sl_aiVertexWeight_Sm__Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)*result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  aiVertexWeight **arg3 = 0 ;
  aiVertexWeight *temp3 = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiVertexWeight *)jarg3;
  arg3 = (aiVertexWeight **)&temp3; 
  try {
    std_vector_Sl_aiVertexWeight_Sm__Sg__setitem(arg1,arg2,(aiVertexWeight *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  std::vector< aiVertexWeight * > *arg2 = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (std::vector< aiVertexWeight * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVertexWeight * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_aiVertexWeight_Sm__Sg__AddRange(arg1,(std::vector< aiVertexWeight * > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVertexWeightVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< aiVertexWeight * > *result = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< aiVertexWeight * > *)std_vector_Sl_aiVertexWeight_Sm__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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  aiVertexWeight **arg3 = 0 ;
  aiVertexWeight *temp3 = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (aiVertexWeight *)jarg3;
  arg3 = (aiVertexWeight **)&temp3; 
  try {
    std_vector_Sl_aiVertexWeight_Sm__Sg__Insert(arg1,arg2,(aiVertexWeight *const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  std::vector< aiVertexWeight * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVertexWeight * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVertexWeight * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiVertexWeight_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiVertexWeight * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_aiVertexWeight_Sm__Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiVertexWeight_Sm__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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_aiVertexWeightVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  aiVertexWeight **arg1 = 0 ;
  int arg2 ;
  aiVertexWeight *temp1 = 0 ;
  std::vector< aiVertexWeight * > *result = 0 ;
  
  temp1 = (aiVertexWeight *)jarg1;
  arg1 = (aiVertexWeight **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< aiVertexWeight * > *)std_vector_Sl_aiVertexWeight_Sm__Sg__Repeat((aiVertexWeight *const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  std_vector_Sl_aiVertexWeight_Sm__Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_aiVertexWeight_Sm__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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_aiVertexWeightVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  int arg2 ;
  std::vector< aiVertexWeight * > *arg3 = 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< aiVertexWeight * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVertexWeight * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_aiVertexWeight_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiVertexWeight * > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVertexWeightVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  aiVertexWeight **arg2 = 0 ;
  aiVertexWeight *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  temp2 = (aiVertexWeight *)jarg2;
  arg2 = (aiVertexWeight **)&temp2; 
  result = (bool)std_vector_Sl_aiVertexWeight_Sm__Sg__Contains(arg1,(aiVertexWeight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiVertexWeightVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  aiVertexWeight **arg2 = 0 ;
  aiVertexWeight *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  temp2 = (aiVertexWeight *)jarg2;
  arg2 = (aiVertexWeight **)&temp2; 
  result = (int)std_vector_Sl_aiVertexWeight_Sm__Sg__IndexOf(arg1,(aiVertexWeight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_aiVertexWeightVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  aiVertexWeight **arg2 = 0 ;
  aiVertexWeight *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  temp2 = (aiVertexWeight *)jarg2;
  arg2 = (aiVertexWeight **)&temp2; 
  result = (int)std_vector_Sl_aiVertexWeight_Sm__Sg__LastIndexOf(arg1,(aiVertexWeight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVertexWeightVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  aiVertexWeight **arg2 = 0 ;
  aiVertexWeight *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  temp2 = (aiVertexWeight *)jarg2;
  arg2 = (aiVertexWeight **)&temp2; 
  result = (bool)std_vector_Sl_aiVertexWeight_Sm__Sg__Remove(arg1,(aiVertexWeight *const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVertexWeightVector(void * jarg1) {
  std::vector< aiVertexWeight * > *arg1 = (std::vector< aiVertexWeight * > *) 0 ;
  
  arg1 = (std::vector< aiVertexWeight * > *)jarg1; 
  delete arg1;
}


#ifdef __cplusplus
}
#endif